%newobject MEDCoupling::MEDFileUMesh::extractFamilyFieldOnGeoType;
%newobject MEDCoupling::MEDFileUMesh::extractNumberFieldOnGeoType;
%newobject MEDCoupling::MEDFileUMesh::zipCoords;
+%newobject MEDCoupling::MEDFileUMesh::deduceNodeSubPartFromCellSubPart;
+%newobject MEDCoupling::MEDFileUMesh::extractPart;
%newobject MEDCoupling::MEDFileUMesh::buildExtrudedMesh;
%newobject MEDCoupling::MEDFileUMesh::linearToQuadratic;
%newobject MEDCoupling::MEDFileUMesh::quadraticToLinear;
+%newobject MEDCoupling::MEDFileUMesh::symmetry3DPlane;
+%newobject MEDCoupling::MEDFileUMesh::Aggregate;
+%newobject MEDCoupling::MEDFileUMesh::convertToExtrudedMesh;
%newobject MEDCoupling::MEDFileCMesh::New;
%newobject MEDCoupling::MEDFileCurveLinearMesh::New;
%newobject MEDCoupling::MEDFileMeshMultiTS::New;
%newobject MEDCoupling::MEDFileFields::__iter__;
%newobject MEDCoupling::MEDFileFields::extractPart;
+%newobject MEDCoupling::MEDFileWritableStandAlone::serialize;
%newobject MEDCoupling::MEDFileAnyTypeFieldMultiTS::New;
%newobject MEDCoupling::MEDFileAnyTypeFieldMultiTS::deepCopy;
%newobject MEDCoupling::MEDFileAnyTypeFieldMultiTS::shallowCpy;
%newobject MEDCoupling::MEDFileData::getMeshes;
%newobject MEDCoupling::MEDFileData::getFields;
%newobject MEDCoupling::MEDFileData::getParams;
+%newobject MEDCoupling::MEDFileData::Aggregate;
%newobject MEDCoupling::MEDFileParameterDouble1TS::New;
%newobject MEDCoupling::MEDFileParameterDouble1TS::deepCopy;
namespace MEDCoupling
{
bool HasXDR();
- std::string MEDFileVersionStr();
+ std::string MEDFileVersionStr() throw(INTERP_KERNEL::Exception);
+ std::string MEDFileVersionOfFileStr(const std::string& fileName) throw(INTERP_KERNEL::Exception);
void SetEpsilonForNodeComp(double val) throw(INTERP_KERNEL::Exception);
void SetCompPolicyForCell(int val) throw(INTERP_KERNEL::Exception);
void SetTooLongStrPolicy(int val) throw(INTERP_KERNEL::Exception);
%inline
{
- PyObject *MEDFileVersionSwig()
+ PyObject *MEDFileVersionSwig() throw(INTERP_KERNEL::Exception)
{
int major,minor,release;
MEDCoupling::MEDFileVersion(major,minor,release);
return ret;
}
- PyObject *GetFieldIterationsSwig(MEDCoupling::TypeOfField type, const std::string& fileName, const std::string& meshName, const std::string& fieldName)
+ PyObject *GetFieldIterationsSwig(MEDCoupling::TypeOfField type, const std::string& fileName, const std::string& meshName, const std::string& fieldName) throw(INTERP_KERNEL::Exception)
{
std::vector< std::pair<int,int> > res=MEDCoupling::GetFieldIterations(type,fileName,meshName,fieldName);
PyObject *ret=PyList_New(res.size());
int getZipConnPolicy() throw(INTERP_KERNEL::Exception);
void setZipConnPolicy(int newVal) throw(INTERP_KERNEL::Exception);
};
+
+ class MEDFileWritableStandAlone : public MEDFileWritable
+ {
+ public:
+ void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
+ void write30(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
+ %extend
+ {
+ DataArrayByte *serialize() const throw(INTERP_KERNEL::Exception)
+ {
+ MCAuto<DataArrayByte> ret(self->serialize());
+ return ret.retn();
+ }
+ PyObject *__getstate__() throw(INTERP_KERNEL::Exception)
+ {
+ PyObject *ret(PyList_New(0));
+ return ret;
+ }
+
+ void __setstate__(PyObject *inp) throw(INTERP_KERNEL::Exception)
+ {
+ }
+
+ PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception)
+ {
+#ifdef WITH_NUMPY
+ PyObject *ret(PyTuple_New(1));
+ PyObject *ret0(PyDict_New());
+ DataArrayByte *retCpp(MEDCoupling_MEDFileWritableStandAlone_serialize(self));
+ PyObject *numpyArryObj=SWIG_NewPointerObj(SWIG_as_voidptr(retCpp),SWIGTYPE_p_MEDCoupling__DataArrayByte, SWIG_POINTER_OWN | 0 );
+ {// create a dict to discriminite in __new__ if __init__ should be called. Not beautiful but not idea ...
+ PyObject *tmp1(PyInt_FromLong(0));
+ PyDict_SetItem(ret0,tmp1,numpyArryObj); Py_DECREF(tmp1); Py_DECREF(numpyArryObj);
+ PyTuple_SetItem(ret,0,ret0);
+ }
+ return ret;
+#else
+ throw INTERP_KERNEL::Exception("PyWrap of MEDFileData.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !");
+#endif
+ }
+ }
+ };
+
class MEDFileMeshReadSelector
{
public:
}
};
- class MEDFileJoint : public RefCountObject, public MEDFileWritable
+ class MEDFileJoint : public RefCountObject, public MEDFileWritableStandAlone
{
public:
static MEDFileJoint *New() throw(INTERP_KERNEL::Exception);
void pushStep(MEDFileJointOneStep* step);
int getNumberOfSteps() const;
MEDFileJointOneStep *getStepAtPos(int i) const;
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
std::string simpleRepr() const;
%extend
{
}
};
- class MEDFileJoints : public RefCountObject, public MEDFileWritable
+ class MEDFileJoints : public RefCountObject, public MEDFileWritableStandAlone
{
public:
static MEDFileJoints *New() throw(INTERP_KERNEL::Exception);
static MEDFileJoints *New(const std::string& fileName, const std::string& meshName) throw(INTERP_KERNEL::Exception);
MEDFileJoints *deepCopy() const;
std::string simpleRepr() const;
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
std::string getMeshName() const;
int getNumberOfJoints() const;
std::vector<std::string> getJointsNames() const;
}
};
- class MEDFileEquivalenceBase : public RefCountObject
+ class MEDFileEquivalenceBase : public RefCountObject, public MEDFileWritableStandAlone
{
private:
MEDFileEquivalenceBase();
}
};
- class MEDFileEquivalencePair : public RefCountObject
+ class MEDFileEquivalencePair : public RefCountObject, public MEDFileWritableStandAlone
{
private:
MEDFileEquivalencePair();
}
};
- class MEDFileEquivalences : public RefCountObject
+ class MEDFileEquivalences : public RefCountObject, public MEDFileWritableStandAlone
{
private:
MEDFileEquivalences();
}
};
- class MEDFileMesh : public RefCountObject, public MEDFileWritable
+ class MEDFileMesh : public RefCountObject, public MEDFileWritableStandAlone
{
public:
static MEDFileMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception);
static MEDFileMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception);
+ static MEDFileMesh *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
virtual MEDFileMesh *createNewEmpty() const throw(INTERP_KERNEL::Exception);
virtual MEDFileMesh *deepCopy() const throw(INTERP_KERNEL::Exception);
virtual MEDFileMesh *shallowCpy() const throw(INTERP_KERNEL::Exception);
virtual MEDFileMesh *cartesianize() const throw(INTERP_KERNEL::Exception);
std::vector<int> getNonEmptyLevels() const throw(INTERP_KERNEL::Exception);
std::vector<int> getNonEmptyLevelsExt() const throw(INTERP_KERNEL::Exception);
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
int getSizeAtLevel(int meshDimRelToMaxExt) const throw(INTERP_KERNEL::Exception);
//
bool existsGroup(const std::string& groupName) const throw(INTERP_KERNEL::Exception);
public:
static MEDFileUMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception);
static MEDFileUMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception);
+ static MEDFileUMesh *New(const MEDCouplingMappedExtrudedMesh *mem) throw(INTERP_KERNEL::Exception);
+ static MEDFileUMesh *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
static MEDFileUMesh *New();
+ static const char *GetSpeStr4ExtMesh();
~MEDFileUMesh();
int getSpaceDimension() const throw(INTERP_KERNEL::Exception);
int getRelativeLevOnGeoType(INTERP_KERNEL::NormalizedCellType gt) const throw(INTERP_KERNEL::Exception);
//
void setFamilyNameAttachedOnId(int id, const std::string& newFamName) throw(INTERP_KERNEL::Exception);
void setCoords(DataArrayDouble *coords) throw(INTERP_KERNEL::Exception);
+ void setCoordsForced(DataArrayDouble *coords) throw(INTERP_KERNEL::Exception);
void eraseGroupsAtLevel(int meshDimRelToMaxExt) throw(INTERP_KERNEL::Exception);
void removeMeshAtLevel(int meshDimRelToMax) throw(INTERP_KERNEL::Exception);
void setMeshAtLevel(int meshDimRelToMax, MEDCoupling1GTUMesh *m) throw(INTERP_KERNEL::Exception);
MEDFileUMesh *buildExtrudedMesh(const MEDCouplingUMesh *m1D, int policy) const throw(INTERP_KERNEL::Exception);
MEDFileUMesh *linearToQuadratic(int conversionType=0, double eps=1e-12) const throw(INTERP_KERNEL::Exception);
MEDFileUMesh *quadraticToLinear(double eps=1e-12) const throw(INTERP_KERNEL::Exception);
+ MEDCouplingMappedExtrudedMesh *convertToExtrudedMesh() const throw(INTERP_KERNEL::Exception);
%extend
{
MEDFileUMesh(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception)
return MEDFileUMesh::New(fileName,mrs);
}
+ MEDFileUMesh(const MEDCouplingMappedExtrudedMesh *mem) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileUMesh::New(mem);
+ }
+
+ MEDFileUMesh(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileUMesh::New(db);
+ }
+
MEDFileUMesh()
{
return MEDFileUMesh::New();
self->removeMeshAtLevel(meshDimRelToMax);
}
+ MEDFileUMesh *symmetry3DPlane(PyObject *point, PyObject *normalVector) const throw(INTERP_KERNEL::Exception)
+ {
+ const char msg[]="Python wrap of MEDFileUMesh::symmetry3DPlane : ";
+ double val,val2;
+ DataArrayDouble *a,*a2;
+ DataArrayDoubleTuple *aa,*aa2;
+ std::vector<double> bb,bb2;
+ int sw;
+ const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
+ const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
+ MCAuto<MEDFileUMesh> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
+ return ret.retn();
+ }
+
+ static MEDFileUMesh *Aggregate(PyObject *meshes) throw(INTERP_KERNEL::Exception)
+ {
+ std::vector<const MEDFileUMesh *> meshesCpp;
+ convertFromPyObjVectorOfObj<const MEDCoupling::MEDFileUMesh *>(meshes,SWIGTYPE_p_MEDCoupling__MEDFileUMesh,"MEDFileUMesh",meshesCpp);
+ MCAuto<MEDFileUMesh> ret(MEDFileUMesh::Aggregate(meshesCpp));
+ return ret.retn();
+ }
+
+ PyObject *getAllDistributionOfTypes() const throw(INTERP_KERNEL::Exception)
+ {
+ std::vector< std::pair<int,int> > ret(self->getAllDistributionOfTypes());
+ return convertVecPairIntToPy(ret);
+ }
+
+ DataArrayInt *deduceNodeSubPartFromCellSubPart(PyObject *extractDef) const throw(INTERP_KERNEL::Exception)
+ {
+ std::map<int, MCAuto<DataArrayInt> > extractDefCpp;
+ convertToMapIntDataArrayInt(extractDef,extractDefCpp);
+ return self->deduceNodeSubPartFromCellSubPart(extractDefCpp);
+ }
+
+ MEDFileUMesh *extractPart(PyObject *extractDef) const throw(INTERP_KERNEL::Exception)
+ {
+ std::map<int, MCAuto<DataArrayInt> > extractDefCpp;
+ convertToMapIntDataArrayInt(extractDef,extractDefCpp);
+ return self->extractPart(extractDefCpp);
+ }
+
void setMeshes(PyObject *li, bool renum=false) throw(INTERP_KERNEL::Exception)
{
std::vector<const MEDCouplingUMesh *> ms;
{
public:
static MEDFileCMesh *New();
+ static MEDFileCMesh *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
static MEDFileCMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception);
static MEDFileCMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception);
void setMesh(MEDCouplingCMesh *m) throw(INTERP_KERNEL::Exception);
{
return MEDFileCMesh::New(fileName,mName,dt,it,mrs);
}
+
+ MEDFileCMesh(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileCMesh::New(db);
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileCMesh");
+ }
PyObject *getMesh() const throw(INTERP_KERNEL::Exception)
{
{
public:
static MEDFileCurveLinearMesh *New();
+ static MEDFileCurveLinearMesh *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
static MEDFileCurveLinearMesh *New(const std::string& fileName, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception);
static MEDFileCurveLinearMesh *New(const std::string& fileName, const std::string& mName, int dt=-1, int it=-1, MEDFileMeshReadSelector *mrs=0) throw(INTERP_KERNEL::Exception);
void setMesh(MEDCouplingCurveLinearMesh *m) throw(INTERP_KERNEL::Exception);
{
return MEDFileCurveLinearMesh::New(fileName,mName,dt,it,mrs);
}
+
+ MEDFileCurveLinearMesh(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileCurveLinearMesh::New(db);
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileCurveLinearMesh");
+ }
PyObject *getMesh() const throw(INTERP_KERNEL::Exception)
{
}
};
- class MEDFileMeshMultiTS : public RefCountObject, public MEDFileWritable
+ class MEDFileMeshMultiTS : public RefCountObject, public MEDFileWritableStandAlone
{
public:
static MEDFileMeshMultiTS *New();
static MEDFileMeshMultiTS *New(const std::string& fileName, const std::string& mName) throw(INTERP_KERNEL::Exception);
MEDFileMeshMultiTS *deepCopy() const throw(INTERP_KERNEL::Exception);
std::string getName() const throw(INTERP_KERNEL::Exception);
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
void setOneTimeStep(MEDFileMesh *mesh1TimeStep) throw(INTERP_KERNEL::Exception);
void cartesianizeMe() throw(INTERP_KERNEL::Exception);
%extend
}
};
- class MEDFileMeshes : public RefCountObject, public MEDFileWritable
+ class MEDFileMeshes : public RefCountObject, public MEDFileWritableStandAlone
{
public:
static MEDFileMeshes *New();
- static MEDFileMeshes *New(const std::string& fileName) throw(INTERP_KERNEL::Exception);
+ static MEDFileMeshes *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
MEDFileMeshes *deepCopy() const throw(INTERP_KERNEL::Exception);
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
int getNumberOfMeshes() const throw(INTERP_KERNEL::Exception);
std::vector<std::string> getMeshesNames() const throw(INTERP_KERNEL::Exception);
//
return MEDFileMeshes::New(fileName);
}
+ MEDFileMeshes(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileMeshes::New(db);
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileMeshes");
+ }
+
std::string __str__() const throw(INTERP_KERNEL::Exception)
{
return self->simpleRepr();
}
};
- class MEDFileAnyTypeField1TS : public RefCountObject, public MEDFileFieldGlobsReal, public MEDFileWritable
+ class MEDFileAnyTypeField1TS : public RefCountObject, public MEDFileFieldGlobsReal, public MEDFileWritableStandAlone
{
public:
static MEDFileAnyTypeField1TS *New(const std::string& fileName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
static MEDFileAnyTypeField1TS *New(const std::string& fileName, const std::string& fieldName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
static MEDFileAnyTypeField1TS *New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll=true) throw(INTERP_KERNEL::Exception);
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
void loadArrays() throw(INTERP_KERNEL::Exception);
void loadArraysIfNecessary() throw(INTERP_KERNEL::Exception);
void unloadArrays() throw(INTERP_KERNEL::Exception);
static MEDFileField1TS *New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll=true) throw(INTERP_KERNEL::Exception);
static MEDFileField1TS *New(const std::string& fileName, const std::string& fieldName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
static MEDFileField1TS *New(const std::string& fileName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
+ static MEDFileField1TS *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
static MEDFileField1TS *New();
MEDCoupling::MEDFileIntField1TS *convertToInt(bool isDeepCpyGlobs=true) const throw(INTERP_KERNEL::Exception);
MEDCouplingFieldDouble *field(const MEDFileMesh *mesh) const throw(INTERP_KERNEL::Exception);
return MEDFileField1TS::New(fileName,fieldName,iteration,order,loadAll);
}
+ MEDFileField1TS(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileField1TS::New(db);
+ }
+
MEDFileField1TS()
{
return MEDFileField1TS::New();
}
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileField1TS");
+ }
+
void copyTinyInfoFrom(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
{
const DataArrayDouble *arr=0;
public:
static MEDFileIntField1TS *New();
static MEDFileIntField1TS *New(const std::string& fileName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
+ static MEDFileIntField1TS *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
static MEDFileIntField1TS *New(const std::string& fileName, const std::string& fieldName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
static MEDFileIntField1TS *New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll=true) throw(INTERP_KERNEL::Exception);
MEDCoupling::MEDFileField1TS *convertToDouble(bool isDeepCpyGlobs=true) const throw(INTERP_KERNEL::Exception);
return MEDFileIntField1TS::New(fileName,fieldName,iteration,order,loadAll);
}
+ MEDFileIntField1TS(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileIntField1TS::New(db);
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileIntField1TS");
+ }
+
std::string __str__() const throw(INTERP_KERNEL::Exception)
{
return self->simpleRepr();
}
};
- class MEDFileAnyTypeFieldMultiTS : public RefCountObject, public MEDFileFieldGlobsReal, public MEDFileWritable
+ class MEDFileAnyTypeFieldMultiTS : public RefCountObject, public MEDFileFieldGlobsReal, public MEDFileWritableStandAlone
{
public:
static MEDFileAnyTypeFieldMultiTS *New(const std::string& fileName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
void eraseEmptyTS() throw(INTERP_KERNEL::Exception);
int getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception);
int getPosGivenTime(double time, double eps=1e-8) const throw(INTERP_KERNEL::Exception);
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
void loadArrays() throw(INTERP_KERNEL::Exception);
void loadArraysIfNecessary() throw(INTERP_KERNEL::Exception);
void unloadArrays() throw(INTERP_KERNEL::Exception);
PyObject *getIterations() const throw(INTERP_KERNEL::Exception)
{
- std::vector< std::pair<int,int> > res=self->getIterations();
- PyObject *ret=PyList_New(res.size());
- int rk=0;
- for(std::vector< std::pair<int,int> >::const_iterator iter=res.begin();iter!=res.end();iter++,rk++)
- {
- PyObject *elt=PyTuple_New(2);
- PyTuple_SetItem(elt,0,SWIG_From_int((*iter).first));
- PyTuple_SetItem(elt,1,SWIG_From_int((*iter).second));
- PyList_SetItem(ret,rk,elt);
- }
- return ret;
+ std::vector< std::pair<int,int> > res(self->getIterations());
+ return convertVecPairIntToPy(res);
}
PyObject *getTimeSteps() const throw(INTERP_KERNEL::Exception)
static MEDFileFieldMultiTS *New() throw(INTERP_KERNEL::Exception);
static MEDFileFieldMultiTS *New(const std::string& fileName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
static MEDFileFieldMultiTS *New(const std::string& fileName, const std::string& fieldName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
+ static MEDFileFieldMultiTS *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
//
MEDCouplingFieldDouble *field(int iteration, int order, const MEDFileMesh *mesh) const throw(INTERP_KERNEL::Exception);
MEDCouplingFieldDouble *getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol=0) const throw(INTERP_KERNEL::Exception);
{
return MEDFileFieldMultiTS::New(fileName,fieldName,loadAll);
}
+
+ MEDFileFieldMultiTS(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileFieldMultiTS::New(db);
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileFieldMultiTS");
+ }
static MEDFileFieldMultiTS *LoadSpecificEntities(const std::string& fileName, const std::string& fieldName, PyObject *entities, bool loadAll=true)
{
static MEDFileIntFieldMultiTS *New();
static MEDFileIntFieldMultiTS *New(const std::string& fileName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
static MEDFileIntFieldMultiTS *New(const std::string& fileName, const std::string& fieldName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
+ static MEDFileIntFieldMultiTS *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
//
void appendFieldNoProfileSBT(const MEDCouplingFieldInt *field) throw(INTERP_KERNEL::Exception);
void appendFieldProfile(const MEDCouplingFieldInt *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception);
return MEDFileIntFieldMultiTS::New(fileName,fieldName,loadAll);
}
+ MEDFileIntFieldMultiTS(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileIntFieldMultiTS::New(db);
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileIntFieldMultiTS");
+ }
+
static MEDFileIntFieldMultiTS *LoadSpecificEntities(const std::string& fileName, const std::string& fieldName, PyObject *entities, bool loadAll=true)
{
std::vector<std::pair<int,int> > tmp(convertTimePairIdsFromPy(entities));
}
};
- class MEDFileFields : public RefCountObject, public MEDFileFieldGlobsReal, public MEDFileWritable
+ class MEDFileFields : public RefCountObject, public MEDFileFieldGlobsReal, public MEDFileWritableStandAlone
{
public:
static MEDFileFields *New() throw(INTERP_KERNEL::Exception);
static MEDFileFields *New(const std::string& fileName, bool loadAll=true) throw(INTERP_KERNEL::Exception);
+ static MEDFileFields *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
static MEDFileFields *LoadPartOf(const std::string& fileName, bool loadAll=true, const MEDFileMeshes *ms=0) throw(INTERP_KERNEL::Exception);
MEDFileFields *deepCopy() const throw(INTERP_KERNEL::Exception);
MEDFileFields *shallowCpy() const throw(INTERP_KERNEL::Exception);
void loadArraysIfNecessary() throw(INTERP_KERNEL::Exception);
void unloadArrays() throw(INTERP_KERNEL::Exception);
void unloadArraysWithoutDataLoss() throw(INTERP_KERNEL::Exception);
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
int getNumberOfFields() const;
std::vector<std::string> getFieldsNames() const throw(INTERP_KERNEL::Exception);
std::vector<std::string> getMeshesNames() const throw(INTERP_KERNEL::Exception);
{
return MEDFileFields::New(fileName,loadAll);
}
+
+ MEDFileFields(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileFields::New(db);
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileFields");
+ }
std::string __str__() const throw(INTERP_KERNEL::Exception)
{
}
};
- class MEDFileParameters : public RefCountObject, public MEDFileWritable
+ class MEDFileParameters : public RefCountObject, public MEDFileWritableStandAlone
{
public:
static MEDFileParameters *New();
static MEDFileParameters *New(const std::string& fileName) throw(INTERP_KERNEL::Exception);
+ static MEDFileParameters *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
MEDFileParameters *deepCopy() const throw(INTERP_KERNEL::Exception);
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
std::vector<std::string> getParamsNames() const throw(INTERP_KERNEL::Exception);
std::string simpleRepr() const throw(INTERP_KERNEL::Exception);
void resize(int newSize) throw(INTERP_KERNEL::Exception);
return MEDFileParameters::New(fileName);
}
+ MEDFileParameters(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileParameters::New(db);
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileParameters");
+ }
+
std::string __str__() const throw(INTERP_KERNEL::Exception)
{
return self->simpleRepr();
}
};
- class MEDFileData : public RefCountObject, public MEDFileWritable
+ class MEDFileData : public RefCountObject, public MEDFileWritableStandAlone
{
public:
+ static MEDFileData *New(DataArrayByte *db) throw(INTERP_KERNEL::Exception);
static MEDFileData *New(const std::string& fileName) throw(INTERP_KERNEL::Exception);
static MEDFileData *New();
MEDFileData *deepCopy() const throw(INTERP_KERNEL::Exception);
bool changeMeshName(const std::string& oldMeshName, const std::string& newMeshName) throw(INTERP_KERNEL::Exception);
bool unPolyzeMeshes() throw(INTERP_KERNEL::Exception);
//
- void write(const std::string& fileName, int mode) const throw(INTERP_KERNEL::Exception);
%extend
{
MEDFileData(const std::string& fileName) throw(INTERP_KERNEL::Exception)
return MEDFileData::New(fileName);
}
+ MEDFileData(DataArrayByte *db) throw(INTERP_KERNEL::Exception)
+ {
+ return MEDFileData::New(db);
+ }
+
MEDFileData()
{
return MEDFileData::New();
std::vector< std::pair<std::string,std::string> > modifTab=convertVecPairStStFromPy(li);
return self->changeMeshNames(modifTab);
}
+
+ static MEDFileData *Aggregate(PyObject *mfds) throw(INTERP_KERNEL::Exception)
+ {
+ std::vector<const MEDFileData *> mfdsCpp;
+ convertFromPyObjVectorOfObj<const MEDCoupling::MEDFileData *>(mfds,SWIGTYPE_p_MEDCoupling__MEDFileData,"MEDFileData",mfdsCpp);
+ MCAuto<MEDFileData> ret(MEDFileData::Aggregate(mfdsCpp));
+ return ret.retn();
+ }
+
+ // serialization
+ static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
+ {
+ return NewMethWrapCallInitOnlyIfDictWithSingleEltInInput(cls,args,"MEDFileData");
+ }
}
};