#
fMEDFileRead2 = ml.MEDFileField1TS("TargetMesh2.med",fPart.getName(),7,8)
fPartRead, pflRead = fMEDFileRead2.getFieldWithProfile(ml.ON_CELLS,0,meshMEDFileRead)
- print "Is the partial field correclty read?", fPartRead.isEqualWithoutConsideringStr(fPart.getArray(),1e-12)
+ print "Is the partial field correctly read?", fPartRead.isEqualWithoutConsideringStr(fPart.getArray(),1e-12)
print "Is the list of cell identifiers matching?", pflRead.isEqualWithoutConsideringStr(pfl)
fMEDFileRead2 = ml.MEDFileField1TS("TargetMesh2.med",fPart.getName(),7,8)
fPartRead, pflRead = fMEDFileRead2.getFieldWithProfile(ml.ON_CELLS,0,meshMEDFileRead)
- print "Is the partial field correclty read?", fPartRead.isEqualWithoutConsideringStr(fPart.getArray(),1e-12)
+ print "Is the partial field correctly read?", fPartRead.isEqualWithoutConsideringStr(fPart.getArray(),1e-12)
print "Is the list of cell identifiers matching?", pflRead.isEqualWithoutConsideringStr(pfl)
Solution
Take a look at \ref library
\subsubsection f-visu How can I visualize a mesh and/or a field?
-Use the PARAVIS module of SALOME to visualize your MED file. The following dedicated fitlers have been
+Use the PARAVIS module of SALOME to visualize your MED file. The following dedicated filters have been
written specifically for MED files: Extract group, Extract cell types, ELNO Mesh, ELNO Points, ELNO Surface.
\subsubsection f-p0p1 What does a P0- (or P1-) field mean?
understood to efficiently deal with \ref meshes "Meshes" and \ref fields "Fields".
\ref MEDCoupling::DataArray "DataArrays" are the atomic element of potentially heavy-memory objects in
-the 3 modules mentionned above.
+the 3 modules mentioned above.
There are for the moment two types of arrays :
- double precision float (64 bits) array incarnated by \ref MEDCoupling::DataArrayDouble "DataArrayDouble class".
\section MEDCouplingArrayRenumberingO2N Old-to-new mode
-The old to new mode is particularly recommanded for surjective and bijective applications. This
+The old to new mode is particularly recommended for surjective and bijective applications. This
is typically the case of \ref MEDCoupling::MEDCouplingUMesh::mergeNodes "MEDCouplingUMesh::mergeNodes" method.
Let's consider a call to \ref MEDCoupling::MEDCouplingUMesh::mergeNodes "mergeNodes" that reduces the
number of nodes from 5 nodes to 3 nodes.\n
}
/*!
- * This method splits 'this' with 'other' into smaller pieces localizable. 'mapThis' is a map that gives the correspondance
+ * This method splits 'this' with 'other' into smaller pieces localizable. 'mapThis' is a map that gives the correspondence
* between nodes contained in 'this' and node ids in a global mesh.
- * In the same way, 'mapOther' gives the correspondance between nodes contained in 'other' and node ids in a
+ * In the same way, 'mapOther' gives the correspondence between nodes contained in 'other' and node ids in a
* global mesh from which 'other' is extracted.
* This method has 1 out parameter : 'edgesThis', After the call of this method, it contains the nodal connectivity (including type)
* of 'this' into globlal "this mesh".
}
if(!found)
throw Exception("Internal error: polygons incompatible with each others. Should never happen!");
- //Ok we found correspondance between this and pol1. Searching for right direction to close polygon.
+ //Ok we found correspondence between this and pol1. Searching for right direction to close polygon.
ElementaryEdge *e=_sub_edges.back();
if(e->getLoc()==FULL_ON_1)
{
// Define 8 hexahedral subzones as in Grandy, p449
// the values correspond to the nodes that correspond to nodes 1,2,3,4,5,6,7,8 in the subcell
- // For the correspondance of the nodes, see the GENERAL_48_SUB_NODES table in calculateSubNodes
+ // For the correspondence of the nodes, see the GENERAL_48_SUB_NODES table in calculateSubNodes
static const int GENERAL_48_SUBZONES[64] =
{
0,8,21,12,9,20,26,22,
{
// The two nodes of the original mesh cell used in each tetrahedron.
// The tetrahedra all have nodes (cellCenter, faceCenter, edgeNode1, edgeNode2)
- // For the correspondance of the nodes, see the GENERAL_48_SUB_NODES table in calculateSubNodes
+ // For the correspondence of the nodes, see the GENERAL_48_SUB_NODES table in calculateSubNodes
// nodes to use for tetrahedron
const double* nodes[4];
* For the other two halfstrips (above the xy and yz edges), other double products are used, which
* are stored in the table DP_FOR_HALFSTRIP_INTERSECTION. This allows us to treat
* all the edges equally, avoiding switch() - statements. It is the careful choice of order of the enumeration types that makes this
- * possible. Notably, there is a correspondance between the TetraEdge type and the DoubleProduct type (see Grandy, table III) that
+ * possible. Notably, there is a correspondence between the TetraEdge type and the DoubleProduct type (see Grandy, table III) that
* is used throughout the code, permitting statements such as DoubleProduct(some_edge) to work.
* When an intersection point has been detected it is calculated with a corresponding calc* - method in the cases where it
* is not known directly. It is then added to the polygon A and/or B as necessary.
static const double TRIPLE_PRODUCT_ANGLE_THRESHOLD;
- // correspondance facet - double product
+ // correspondence facet - double product
// Grandy, table IV
static const DoubleProduct DP_FOR_SEG_FACET_INTERSECTION[12];
// for Segment-Facet and Segment-Edge intersections
static const int DP_INDEX[12];
- // correspondance edge - corners
+ // correspondence edge - corners
static const TetraCorner CORNERS_FOR_EDGE[12];
- // correspondance edge - facets
+ // correspondence edge - facets
// facets shared by each edge
static const TetraFacet FACET_FOR_EDGE[12];
- // correspondance edge - corners
+ // correspondence edge - corners
static const TetraEdge EDGES_FOR_CORNER[12];
// double products used in segment-halfstrip test
// assert(edge < H01);
- // correspondance edge - triple products
+ // correspondence edge - triple products
// for edges OX, ..., ZX (Grandy, table III)
static const TetraCorner TRIPLE_PRODUCTS[12] =
{
inline bool TransformedTriangle::testSegmentIntersectsFacet(const TriSegment seg, const TetraFacet facet) const
{
- // use correspondance facet a = 0 <=> offset for coordinate a in _coords
- // and also correspondance segment AB => corner A
+ // use correspondence facet a = 0 <=> offset for coordinate a in _coords
+ // and also correspondence segment AB => corner A
const double coord1 = _coords[5*seg + facet];
const double coord2 = _coords[5*( (seg + 1) % 3) + facet];
{
// ----------------------------------------------------------------------------------
- // Correspondance tables describing all the variations of formulas.
+ // Correspondence tables describing all the variations of formulas.
// ----------------------------------------------------------------------------------
- /// \brief Correspondance between facets and double products.
+ /// \brief Correspondence between facets and double products.
///
/// This table encodes Grandy, table IV. Use 3*facet + {0,1,2} as index
const TransformedTriangle::DoubleProduct TransformedTriangle::DP_FOR_SEG_FACET_INTERSECTION[12] =
9, 10, 11 // XYZ
};
- /// \brief Correspondance edge - corners.
+ /// \brief Correspondence edge - corners.
///
/// Gives the two corners associated with each edge
/// Use 2*edge + {0, 1} as index
Z, X // ZX
};
- /// \brief Correspondance edge - facets.
+ /// \brief Correspondence edge - facets.
///
/// Gives the two facets shared by and edge. Use 2*facet + {0, 1} as index
const TransformedTriangle::TetraFacet TransformedTriangle::FACET_FOR_EDGE[12] =
OZX, XYZ // ZX
};
- /// \brief Correspondance corners - edges.
+ /// \brief Correspondence corners - edges.
///
/// Gives edges meeting at a given corner. Use 3*corner + {0,1,2} as index
const TransformedTriangle::TetraEdge TransformedTriangle::EDGES_FOR_CORNER[12] =
{
const DoubleProduct dp = DP_FOR_DETERMINANT_EXPANSION[3*corner + (row - 1)];
- // get edge by using correspondance between Double Product and Edge
+ // get edge by using correspondence between Double Product and Edge
TetraEdge edge = TetraEdge(dp);
// use edge only if it is surrounded by the surface
/*!
* @param comm in param in the same format than one returned by findCommonNodes method (\ref numbering-indirect).
* @param commI in param in the same format than one returned by findCommonNodes method (\ref numbering-indirect).
- * @return the old to new correspondance array.
+ * @return the old to new correspondence array.
*/
DataArrayInt *MEDCouplingPointSet::buildNewNumberingFromCommonNodesFormat(const DataArrayInt *comm, const DataArrayInt *commIndex,
int& newNbOfNodes) const
* \param [out] beginOut valid only if \a arr not NULL !
* \param [out] endOut valid only if \a arr not NULL !
* \param [out] stepOut valid only if \a arr not NULL !
- * \param [out] arr correspondance old to new in node ids.
+ * \param [out] arr correspondence old to new in node ids.
*
* \sa MEDCouplingUMesh::buildPartOfMySelfSlice
*/
if(arrays1[i]!=0 && arrays2[i]!=0)
arrays1[i]->setSelectedComponents(arrays2[i],compoIds);
else if(arrays1[i]!=0 || arrays2[i]!=0)
- throw INTERP_KERNEL::Exception("TimeDiscretization::setSelectedComponents : some time array in correspondance are not defined symmetrically !");
+ throw INTERP_KERNEL::Exception("TimeDiscretization::setSelectedComponents : some time array in correspondence are not defined symmetrically !");
}
}
* \param [in] startCellId specifies the cellId starting from which the equality computation will be carried out. By default it is 0, which it means that all cells in \a this will be scanned.
* \param [out] commonCellsArr common cells ids (\ref numbering-indirect)
* \param [out] commonCellsIArr common cells ids (\ref numbering-indirect)
- * \return the correspondance array old to new in a newly allocated array.
+ * \return the correspondence array old to new in a newly allocated array.
*
*/
void MEDCouplingUMesh::findCommonCells(int compType, int startCellId, DataArrayInt *& commonCellsArr, DataArrayInt *& commonCellsIArr) const
/*!
* This method behaves exactly as MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec but the order is those defined in MED file spec.
*
- * \return a new object containing the old to new correspondance.
+ * \return a new object containing the old to new correspondence.
*
* \sa MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec, MEDCouplingUMesh::sortCellsInMEDFileFrmt.
*/
* This method tries to minimizes the number of needed permutations. So, this method behaves not exactly as
* MEDCouplingUMesh::sortCellsInMEDFileFrmt.
*
- * \return the array giving the correspondance old to new.
+ * \return the array giving the correspondence old to new.
*/
DataArrayInt *MEDCouplingUMesh::rearrange2ConsecutiveCellTypes()
{
* (newly created) nodes corresponding to the edge intersections.
* Output params:
* @param[out] cr, crI connectivity of the resulting mesh
- * @param[out] cNb1, cNb2 correspondance arrays giving for the merged mesh the initial cells IDs in m1 / m2
+ * @param[out] cNb1, cNb2 correspondence arrays giving for the merged mesh the initial cells IDs in m1 / m2
* TODO: describe input parameters
*/
void MEDCouplingUMesh::BuildIntersecting2DCellsFromEdges(double eps, const MEDCouplingUMesh *m1, const int *desc1, const int *descIndx1,
m->checkConsistency();//OK because we are in polyhedron connec
m->getNodalConnectivity()->setIJ(36,0,14);
m->checkConsistencyLight();
- CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);//Throw because now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
+ CPPUNIT_ASSERT_THROW(m->checkConsistency(),INTERP_KERNEL::Exception);//Throw because now cell 5 is a TETRA4 (14) so mismatch of number index and static type.
m->decrRef();
}
m.checkConsistency();#OK because we are in polyhedron connec
m.getNodalConnectivity().setIJ(36,0,14);
m.checkConsistencyLight();
- self.assertRaises(InterpKernelException,m.checkConsistency);#Throw beacause now cell 5 is a TETRA4 (14) so mimatch of number index and static type.
+ self.assertRaises(InterpKernelException,m.checkConsistency);#Throw because now cell 5 is a TETRA4 (14) so mismatch of number index and static type.
pass
def testUnPolyze2(self):
gaussCoords=refCoords[:] ; gaussCoords[14]=0.9999999999999 # change z of point #4 0.999... instead of 1. because with shape function it leads to division by 0. !
fGauss.setGaussLocalizationOnType(NORM_PYRA13,refCoords,gaussCoords,weights)
arrOfDisc2=fGauss.getLocalizationOfDiscr()
- self.assertTrue(arrOfDisc2.isEqual(coo,1e-10)) # be less exigent 1e-10 instead of 1e-12 due to shape function sensitivity arount 0.,0.,1. !
+ self.assertTrue(arrOfDisc2.isEqual(coo,1e-10)) # be less exigent 1e-10 instead of 1e-12 due to shape function sensitivity around 0.,0.,1. !
pass
def testSwig2Tri7GP1(self):
fieldOnCells.setName("MyTensorFieldOnCellNoTime")
fieldOnCells.setMesh(mesh)
array=DataArrayDouble()
- array.alloc(fieldOnCells.getMesh().getNumberOfCells(),9) # Implicitely fieldOnCells will be a 9 components field.
+ array.alloc(fieldOnCells.getMesh().getNumberOfCells(),9) # Implicitly fieldOnCells will be a 9 components field.
array.fillWithValue(7.)
fieldOnCells.setArray(array)
# fieldOnCells is now usable
fieldOnNodes.setName("MyScalarFieldOnNodeNoTime")
fieldOnNodes.setMesh(mesh)
array=DataArrayDouble()
- array.alloc(fieldOnNodes.getMesh().getNumberOfNodes(),1) # Implicitely fieldOnNodes will be a 1 component field.
+ array.alloc(fieldOnNodes.getMesh().getNumberOfNodes(),1) # Implicitly fieldOnNodes will be a 1 component field.
array.fillWithValue(7.)
fieldOnNodes.setArray(array)
# fieldOnNodes is now usable
fieldOnCells.setTime(4.22,2,-1) # Time attached is 4.22 ms, iteration id is 2 and order id (or sub iteration id) is -1
fieldOnCells.setMesh(mesh)
array=DataArrayDouble()
- array.alloc(fieldOnCells.getMesh().getNumberOfCells(),2) # Implicitely fieldOnCells will be a 2 components field.
+ array.alloc(fieldOnCells.getMesh().getNumberOfCells(),2) # Implicitly fieldOnCells will be a 2 components field.
array.fillWithValue(7.)
fieldOnCells.setArray(array)
# fieldOnCells is now usable
fieldOnNodes.setEndTime(6.44,4,-1)# fieldOnNodes is defined in interval [4.22 ms,6.44 ms]
fieldOnNodes.setMesh(mesh)
array=DataArrayDouble()
- array.alloc(fieldOnNodes.getMesh().getNumberOfNodes(),3) # Implicitely fieldOnNodes will be a 3 components field.
+ array.alloc(fieldOnNodes.getMesh().getNumberOfNodes(),3) # Implicitly fieldOnNodes will be a 3 components field.
array.fillWithValue(7.)
fieldOnNodes.setArray(array)
# fieldOnNodes is now usable
@unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
def test21(self):
- #tests that only DataArray*(npArray) contructor is available
+ #tests that only DataArray*(npArray) constructor is available
a=array(0,dtype=int32)
a.resize(20)
DataArrayInt(a)
pass
def testP0P0WithHEXGP12(self):
- """ Test that HEXGP12 are correclty remapped (elements with polygonal faces were not properly handled) """
+ """ Test that HEXGP12 are correctly remapped (elements with polygonal faces were not properly handled) """
# From Astrid, two disjoint hexagonal prisms:
coo1 = [-4.991193077144312, 8.644999999999998, 0.0, -9.982386154288623, 6.112246755425186e-16, 0.0, -4.991193077144315, -8.644999999999998, 0.0, 4.991193077144309, -8.645000000000005, 0.0, 9.982386154288626, 1.1651321638577316e-15, 0.0, 4.991193077144314, 8.645, 0.0, -4.991193077144312, 8.644999999999998, 7.561799999999991, -9.982386154288623, 6.112246755425186e-16, 7.561799999999991, -4.991193077144315, -8.644999999999998, 7.561799999999991, 4.991193077144309, -8.645000000000005, 7.561799999999991, 9.982386154288626, 1.1651321638577316e-15, 7.561799999999991, 4.991193077144314, 8.645, 7.561799999999991]
coo2 = [-4.991193077144313, -8.645, 0.0, -9.982386154288626, -1.3992140779350848e-15, 0.0, -19.964772308577256, 0.0, 0.0, -24.95596538572157, -8.644999999999998, 0.0, -19.96477230857726, -17.289999999999996, 0.0, -9.982386154288626, -17.289999999999996, 0.0, -4.991193077144313, -8.645, 5.041200000000004, -9.982386154288626, -1.3992140779350848e-15, 5.041200000000004, -19.964772308577256, 0.0, 5.041200000000004, -24.95596538572157, -8.644999999999998, 5.041200000000004, -19.96477230857726, -17.289999999999996, 5.041200000000004, -9.982386154288626, -17.289999999999996, 5.041200000000004]
typename Traits<T>::ArrayType *ret2(dynamic_cast<typename Traits<T>::ArrayType *>(ret));
if(!ret2)
{
- std::ostringstream oss; oss << "MEDFileTemplateFieldMultiTS<T>::getUndergroundDataArray : invalid type of data dectected ! Expecting " << MLFieldTraits<T>::F1TSWSDAType::TYPE_STR;
+ std::ostringstream oss; oss << "MEDFileTemplateFieldMultiTS<T>::getUndergroundDataArray : invalid type of data detected ! Expecting " << MLFieldTraits<T>::F1TSWSDAType::TYPE_STR;
throw INTERP_KERNEL::Exception(oss.str());
}
return ret2;
typename Traits<T>::ArrayType *ret2(dynamic_cast<typename Traits<T>::ArrayType *>(ret));
if(!ret2)
{
- std::ostringstream oss; oss << "MEDFileTemplateFieldMultiTS<T>::getUndergroundDataArrayExt : invalid type of data dectected ! Expecting " << MLFieldTraits<T>::F1TSWSDAType::TYPE_STR;
+ std::ostringstream oss; oss << "MEDFileTemplateFieldMultiTS<T>::getUndergroundDataArrayExt : invalid type of data detected ! Expecting " << MLFieldTraits<T>::F1TSWSDAType::TYPE_STR;
throw INTERP_KERNEL::Exception(oss.str());
}
return ret2;
void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos)
{
DataArray *arr=getOrCreateAndGetArray();
- arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
+ arr->setInfoOnComponents(infos);//will throw an exception if number of components mismatches
}
/*!
* \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
* \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
* \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
- * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
+ * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondence with the MEDFileField. The mesh inside the \a field is simply ignored.
*/
void MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile(bool isPflAlone, int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldTemplate *field, const DataArray *arrr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
{
* \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
* \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
* \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
- * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
+ * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondence with the MEDFileField. The mesh inside the \a field is simply ignored.
*/
void MEDFileFieldPerMeshPerTypeCommon::assignFieldProfile(bool isPflAlone, int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldTemplate *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
{
* \param [in] code2 is the code of the \b WHOLE mesh on the same level. So all types in \a code are in \a code2.
* \param [in] idsInPflPerType is the selection into the \a multiTypePfl whole profile that corresponds to the given geometric type. This vector is always 3 times smaller than \a code.
* \param [in] idsPerType is a vector containing the profiles needed to be created for MED file format. \b WARNING these processed MED file profiles can be subdivided again in case of Gauss points.
- * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
+ * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondence with the MEDFileField. The mesh inside the \a field is simply ignored.
*/
void MEDFileFieldPerMesh::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const std::vector<int>& code, const std::vector<int>& code2, const std::vector<DataArrayInt *>& idsInPflPerType, const std::vector<DataArrayInt *>& idsPerType, const MEDCouplingFieldTemplate *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
{
/*! \endcond */
/*!
- * Array returned is the correspondance in \b old \b to \b new format. The returned array is newly created and should be dealt by the caller.
+ * Array returned is the correspondence in \b old \b to \b new format. The returned array is newly created and should be dealt by the caller.
* The maximum value stored in returned array is the number of nodes of \a this minus 1 after call of this method.
* The size of returned array is the number of nodes of the old (previous to the call of this method) number of nodes.
* -1 values in returned array means that the corresponding old node is no more used.
*
- * \return newly allocated array containing correspondance in \b old \b to \b new format. If all nodes in \a this are fetched \c NULL pointer is returned and nothing
+ * \return newly allocated array containing correspondence in \b old \b to \b new format. If all nodes in \a this are fetched \c NULL pointer is returned and nothing
* is modified in \a this.
* \throw If no coordinates are set in \a this or if there is in any available mesh in \a this a cell having a nodal connectivity containing a node id not in the range of
* set coordinates.
class CaseWriter(CaseIO):
""" Converting MED file format in memory to a the Case file format (Ensight).
- A new file with the same base name and the .case extension is created with its depencies (.geo ...).
+ A new file with the same base name and the .case extension is created with its dependencies (.geo ...).
"""
header="""FORMAT
mml2=mml.prepare()
self.assertTrue(isinstance(mml2,MEDUMeshMultiLev))
ncc,a0,a1,a2,a3,a4,a5=mml2.buildVTUArrays()
- self.assertTrue(not ncc)# false beacause 2D in MED file
+ self.assertTrue(not ncc)# false because 2D in MED file
self.assertTrue(a0.isEqual(DataArrayDouble([(5.5,0.5,0),(5.5,-0.5,0),(6.5,0.5,0),(6.5,-0.5,0),(6.5,1.5,0),(7.5,0.5,0),(7.5,-0.5,0),(7.5,1.5,0),(7.5,2.5,0),(8.5,0.5,0),(8.5,-0.5,0),(8.5,1.5,0),(8.5,2.5,0),(8.5,3.5,0),(8.55,0.5,0),(8.55,-0.5,0),(8.55,1.5,0),(8.55,2.5,0),(8.55,3.5,0)]),1e-12))
self.assertTrue(a1.isEqual(DataArrayByte([9,9,9,9,9,9,7,7,7,7])))
self.assertTrue(a2.isEqual(DataArrayInt([0,5,10,15,20,25,30,35,40,45])))# the bug was here.
strstream << "usage :" << endl
<< "mpirun -np <nbprocs> test_AllToAllDEC" << endl
<< " (nbprocs >=2)" << endl
- << "test must be runned with more than 1 proc and less than 12 procs"
+ << "test must be run with more than 1 proc and less than 12 procs"
<< endl ;
cerr << strstream.str() << endl ;
CPPUNIT_FAIL( strstream.str() ) ;
strstream << "usage :" << endl
<< "mpirun -np <nbprocs> test_AllToAllTimeDEC" << endl
<< " (nbprocs >=2)" << endl
- << "test must be runned with more than 1 proc and less than 12 procs"
+ << "test must be run with more than 1 proc and less than 12 procs"
<< endl ;
cerr << strstream.str() << endl ;
CPPUNIT_FAIL( strstream.str() ) ;
strstream << "usage :" << endl
<< "mpirun -np <nbprocs> test_AllToAllvDEC" << endl
<< " (nbprocs >=2)" << endl
- << "test must be runned with more than 1 proc and less than 12 procs"
+ << "test must be run with more than 1 proc and less than 12 procs"
<< endl ;
cerr << strstream.str() << endl ;
CPPUNIT_FAIL( strstream.str() ) ;
strstream << "usage :" << endl
<< "mpirun -np <nbprocs> test_AllToAllTimeDEC" << endl
<< " (nbprocs >=2)" << endl
- << "test must be runned with more than 1 proc and less than 12 procs"
+ << "test must be run with more than 1 proc and less than 12 procs"
<< endl ;
cerr << strstream.str() << endl ;
CPPUNIT_FAIL( strstream.str() ) ;
strstream << "usage :" << endl
<< "mpirun -np <nbprocs> test_AllToAllTimeDEC" << endl
<< " (nbprocs >=2)" << endl
- << "test must be runned with more than 1 proc and less than 12 procs"
+ << "test must be run with more than 1 proc and less than 12 procs"
<< endl ;
cerr << strstream.str() << endl ;
CPPUNIT_FAIL( strstream.str() ) ;
if ( size < 2 ) {
ostringstream strstream ;
- strstream << "test_MPI_Access_Cancel must be runned with 2 procs" << endl ;
+ strstream << "test_MPI_Access_Cancel must be run with 2 procs" << endl ;
cerr << strstream.str() << endl ;
//CPPUNIT_FAIL( strstream.str() ) ;
return;
MPI_Comm_rank(MPI_COMM_WORLD,&myrank) ;
if ( size < 3 ) {
- cerr << "test_MPI_Access_Cyclic_ISend_IRecv must be runned with 3 procs" << endl ;
- //CPPUNIT_FAIL("test_MPI_Access_Cyclic_ISend_IRecv must be runned with 3 procs") ;
+ cerr << "test_MPI_Access_Cyclic_ISend_IRecv must be run with 3 procs" << endl ;
+ //CPPUNIT_FAIL("test_MPI_Access_Cyclic_ISend_IRecv must be run with 3 procs") ;
return;
}
MPI_Comm_rank(MPI_COMM_WORLD,&myrank) ;
if ( size < 3 ) {
- cerr << "test_MPI_Access_Send_Recv must be runned with 3 procs" << endl ;
- //CPPUNIT_FAIL("test_MPI_Access_Send_Recv must be runned with 3 procs") ;
+ cerr << "test_MPI_Access_Send_Recv must be run with 3 procs" << endl ;
+ //CPPUNIT_FAIL("test_MPI_Access_Send_Recv must be run with 3 procs") ;
return;
}
if ( size < 2 ) {
ostringstream strstream ;
- strstream << "test_MPI_Access_IProbe must be runned with 2 procs" << endl ;
+ strstream << "test_MPI_Access_IProbe must be run with 2 procs" << endl ;
cerr << strstream.str() << endl ;
//CPPUNIT_FAIL( strstream.str() ) ;
return;
MPI_Comm_rank(MPI_COMM_WORLD,&myrank) ;
if ( size < 2 ) {
- cerr << "test_MPI_Access_ISendRecv must be runned with 2 procs" << endl ;
- //CPPUNIT_FAIL("test_MPI_Access_ISendRecv must be runned with 2 procs") ;
+ cerr << "test_MPI_Access_ISendRecv must be run with 2 procs" << endl ;
+ //CPPUNIT_FAIL("test_MPI_Access_ISendRecv must be run with 2 procs") ;
return;
}
MPI_Comm_rank(MPI_COMM_WORLD,&myrank) ;
if ( size < 2 ) {
- cerr << "test_MPI_Access_ISend_IRecv must be runned with 2 procs" << endl ;
- //CPPUNIT_FAIL("test_MPI_Access_ISend_IRecv must be runned with 2 procs") ;
+ cerr << "test_MPI_Access_ISend_IRecv must be run with 2 procs" << endl ;
+ //CPPUNIT_FAIL("test_MPI_Access_ISend_IRecv must be run with 2 procs") ;
return;
}
if ( size < 2 ) {
ostringstream strstream ;
- strstream << "test_MPI_Access_ISend_IRecv_BottleNeck must be runned with 2 procs"
+ strstream << "test_MPI_Access_ISend_IRecv_BottleNeck must be run with 2 procs"
<< endl ;
cerr << strstream.str() << endl ;
//CPPUNIT_FAIL( strstream.str() ) ;
if ( size < 2 ) {
ostringstream strstream ;
- strstream << "test_MPI_Access_ISend_IRecv_Length must be runned with 2 procs" << endl ;
+ strstream << "test_MPI_Access_ISend_IRecv_Length must be run with 2 procs" << endl ;
cerr << strstream.str() << endl ;
//CPPUNIT_FAIL( strstream.str() ) ;
return;
if ( size < 2 ) {
ostringstream strstream ;
- strstream << "test_MPI_Access_ISend_IRecv_Length_1 must be runned with 2 procs" << endl ;
+ strstream << "test_MPI_Access_ISend_IRecv_Length_1 must be run with 2 procs" << endl ;
cerr << strstream.str() << endl ;
//CPPUNIT_FAIL( strstream.str() ) ;
return;
MPI_Comm_rank(MPI_COMM_WORLD,&myrank) ;
if ( size < 2 ) {
- cerr << "test_MPI_Access_Probe must be runned with 2 procs" << endl ;
- //CPPUNIT_FAIL("test_MPI_Access_Probe must be runned with 2 procs") ;
+ cerr << "test_MPI_Access_Probe must be run with 2 procs" << endl ;
+ //CPPUNIT_FAIL("test_MPI_Access_Probe must be run with 2 procs") ;
return;
}
MPI_Comm_rank(MPI_COMM_WORLD,&myrank) ;
if ( size < 2 ) {
- cerr << "MPIAccessTest::test_MPI_Access_SendRecv must be runned with 2 procs" << endl ;
- //CPPUNIT_FAIL("test_MPI_Access_SendRecv must be runned with 2 procs") ;
+ cerr << "MPIAccessTest::test_MPI_Access_SendRecv must be run with 2 procs" << endl ;
+ //CPPUNIT_FAIL("test_MPI_Access_SendRecv must be run with 2 procs") ;
return;
}
MPI_Comm_rank(MPI_COMM_WORLD,&myrank) ;
if ( size < 2 ) {
- cerr << "test_MPI_Access_Send_Recv must be runned with 2 procs" << endl ;
- //CPPUNIT_FAIL("test_MPI_Access_Send_Recv must be runned with 2 procs") ;
+ cerr << "test_MPI_Access_Send_Recv must be run with 2 procs" << endl ;
+ //CPPUNIT_FAIL("test_MPI_Access_Send_Recv must be run with 2 procs") ;
return;
}
if ( size < 2 ) {
ostringstream strstream ;
- strstream << "test_MPI_Access_Send_Recv_Length must be runned with 2 procs" << endl ;
+ strstream << "test_MPI_Access_Send_Recv_Length must be run with 2 procs" << endl ;
cerr << strstream.str() << endl ;
//CPPUNIT_FAIL( strstream.str() ) ;
return;
if ( size < 2 ) {
ostringstream strstream ;
- strstream << "test_MPI_Access_Time must be runned with 2 procs" << endl ;
+ strstream << "test_MPI_Access_Time must be run with 2 procs" << endl ;
cerr << strstream.str() << endl ;
//CPPUNIT_FAIL( strstream.str() ) ;
return;
strstream << "usage :" << endl
<< "mpirun -np <nbprocs> test_MPI_Access_Time_0" <<endl
<< " nbprocs =2" << endl
- << "test must be runned with 2 procs" << endl ;
+ << "test must be run with 2 procs" << endl ;
cerr << strstream.str() << endl ;
//CPPUNIT_FAIL( strstream.str() ) ;
return;
