*** empty log message ***

[modules/multipr.git] / src / MULTIPR / MULTIPR_MeshDis.cxx

diff --git a/src/MULTIPR/MULTIPR_MeshDis.cxx b/src/MULTIPR/MULTIPR_MeshDis.cxx
index 4f2a301699d4fedc56240923f22baba92e5162d5..3c0571ea2407921bff3fd159635412867c921df0 100644 (file)
--- a/src/MULTIPR/MULTIPR_MeshDis.cxx
+++ b/src/MULTIPR/MULTIPR_MeshDis.cxx
@@ -241,10 +241,6 @@ void MeshDis::insertMesh(
        Mesh*       pMesh,
        int         pPosition)
 {
-       // debug
-       //cout << "INSERT PARTS BEFORE: " << endl;
-       //cout << (*this) << endl;
-       
        MeshDisPart* part = new MeshDisPart();
        
        part->create(
@@ -263,19 +259,11 @@ void MeshDis::insertMesh(
        {
                mParts[i]->mId++;
        }
-       
-       // debug
-       //cout << "INSERT PARTS AFTER: " << endl;
-       //cout << (*this) << endl;
 }
 
 
 void MeshDis::removeParts(const char* pPrefixPartName)
 {
-       // debug
-       //cout << "REMOVE PARTS BEFORE: " << endl;
-       //cout << (*this) << endl;
-       
        if (pPrefixPartName == NULL) throw NullArgumentException("", __FILE__, __LINE__);
        
        char strPrefix[256];
@@ -288,7 +276,7 @@ void MeshDis::removeParts(const char* pPrefixPartName)
                // remove part which have the same name and all sub_parts
                // e.g. if pPrefixPartName="PART_4" => remove "PART_4" and "PART_4_*", but not "PART41"         
                if ((strcmp(currentPart->getPartName(), pPrefixPartName) == 0) || 
-                   startWith(currentPart->getPartName(), strPrefix))
+                   startsWith(currentPart->getPartName(), strPrefix))
                {
                        mParts.erase(itPart);
                
@@ -307,10 +295,6 @@ void MeshDis::removeParts(const char* pPrefixPartName)
                        delete currentPart;
                }
        }
-       
-       // debug
-       //cout << "REMOVE PARTS AFTER: " << endl;
-       //cout << (*this) << endl;
 }
 
 
@@ -455,10 +439,12 @@ string MeshDis::getPartInfo(const char* pPartName)
 
 void MeshDis::splitPart(const char* pPartName, int pNbParts, int pPartitionner)
 {
+       cout << "MULTIPR: MeshDis::splitPart()" << endl;
        if (pPartName == NULL) throw NullArgumentException("", __FILE__, __LINE__);
        if (pNbParts < 2) throw IllegalArgumentException("", __FILE__, __LINE__);
        if ((pPartitionner != MULTIPR_METIS) && (pPartitionner != MULTIPR_SCOTCH)) throw IllegalArgumentException("should be 0=METIS or 1=SCOTCH", __FILE__, __LINE__);
        
+       cout << "MULTIPR: MeshDis::splitPart(): args OK" << endl;
        //---------------------------------------------------------------------
        // Find the MED file corresponding to the given part
        //---------------------------------------------------------------------
@@ -468,6 +454,8 @@ void MeshDis::splitPart(const char* pPartName, int pNbParts, int pPartitionner)
        {
                throw IllegalArgumentException("part not found in this distributed MED file", __FILE__, __LINE__);
        }
+
+       cout << "MULTIPR: MeshDis::splitPart(): find part OK" << endl;
        
        //---------------------------------------------------------------------
        // Load the sequential MED file
@@ -475,6 +463,7 @@ void MeshDis::splitPart(const char* pPartName, int pNbParts, int pPartitionner)
        MEDSPLITTER::MESHCollection* collection;
        collection = new MEDSPLITTER::MESHCollection(part->getMEDFileName(), part->getMeshName());
        
+       cout << "MULTIPR: MeshDis::splitPart(): MEDSPLITTER collection OK" << endl;
        //---------------------------------------------------------------------
        // Partition the group
        //---------------------------------------------------------------------
@@ -494,7 +483,9 @@ void MeshDis::splitPart(const char* pPartName, int pNbParts, int pPartitionner)
        {
                try
                {
+                       cout << "MULTIPR: try to create partition using SCOTCH: #parts=" << pNbParts << endl;
                        topology = collection->createPartition(pNbParts, MEDSPLITTER::Graph::SCOTCH);
+                       cout << "MULTIPR: assigned SCOTCH" << endl;
                }
                catch (...)
                {
@@ -517,6 +508,7 @@ void MeshDis::splitPart(const char* pPartName, int pNbParts, int pPartitionner)
        }
        catch (...)
        {
+               cout << "MEDSPLITTER error: new MESHCollection()" << endl;
                throw RuntimeException("MEDSPLITTER error: new MESHCollection()", __FILE__, __LINE__);
        }
 }
@@ -566,7 +558,9 @@ void MeshDis::decimatePart(
        const char* originalFilename = part->getMEDFileName();
        string strPrefix = removeExtension(originalFilename, ".med");
        
-cout << (*this) << endl;
+       // debug
+       //cout << (*this) << endl;
+       
        //---------------------------------------------------------------------
        // Decimates the given mesh
        //---------------------------------------------------------------------
@@ -634,7 +628,10 @@ string MeshDis::evalDecimationParams(
        const char* pFilterParams)
 {
        MeshDisPart* part = findPart(pPartName);
-       if (part == NULL) return "";
+       if (part == NULL) 
+       {
+               return "";
+       }
        
        try
        {
@@ -644,7 +641,10 @@ string MeshDis::evalDecimationParams(
                }
        
                multipr::DecimationFilter* filter = multipr::DecimationFilter::create(pFilterName);
-               if (filter == NULL) return "";
+               if (filter == NULL) 
+               {
+                       return "";
+               }
                
                multipr::DecimationFilterGradAvg* filterGrad = dynamic_cast<multipr::DecimationFilterGradAvg*>(filter);
                
@@ -693,8 +693,9 @@ string MeshDis::evalDecimationParams(
        }
        catch(...)
        {
-               return "";
        }
+       
+       return "";
 }
 
 
@@ -764,7 +765,7 @@ void MeshDis::readDistributedMED(const char* pMEDfilename)
        
        // read number of parts
        int nbParts = atoi(charbuffer);
-       //cout << "DBG: readDistributedMED: #parts=" << nbParts << endl;
+       //cout << "readDistributedMED: #parts=" << nbParts << endl;
        
        //---------------------------------------------------------------------
        // Read infos about sub-parts
@@ -817,14 +818,13 @@ void MeshDis::readDistributedMED(const char* pMEDfilename)
        //---------------------------------------------------------------------
        fileMaster.close();
        if (fileMaster.fail()) throw IOException("i/o error while closing MED master file", __FILE__, __LINE__);
-       //cout << "DBG: readDistributedMED: close" << endl;
 }
 
 
 /**
  * Retrieves the output of MEDSPLITTER and convert it for MULTIPR.
  */
-int convertMedsplitterToMultipr(ofstream& pFileMaster, const char* pTmpFilename, int pId, MeshDisPart* pPart)
+int convertMedsplitterToMultipr(ofstream& pFileMaster, const char* pTmpFilename, int pId, MeshDisPart* pPart, string pDestPath)
 {
        MULTIPR_LOG("convert" << endl);
        
@@ -846,7 +846,7 @@ int convertMedsplitterToMultipr(ofstream& pFileMaster, const char* pTmpFilename,
 
        // read number of parts
        int nbParts = atoi(charbuffer);
-       cout << "nb parts=" << nbParts << endl;
+       //cout << "nb parts=" << nbParts << endl;
 
        char   lMeshName[MED_TAILLE_NOM + 1];
        int    lId;
@@ -877,6 +877,13 @@ int convertMedsplitterToMultipr(ofstream& pFileMaster, const char* pTmpFilename,
                
                //cout << lMeshName << " " << (pId + i) << " " << pPart->getPartName() << "_" << (i + 1) << " " << lPath << " " << lMEDFileName << endl;
                
+               string strDestFilename = pDestPath + multipr::getFilenameWithoutPath(lMEDFileName);
+               if (strcmp(lMEDFileName, strDestFilename.c_str()) != 0)
+               {
+                       multipr::copyFile(lMEDFileName, pDestPath.c_str());
+                       strcpy(lMEDFileName, strDestFilename.c_str());
+               }
+                               
                pFileMaster << lMeshName << " " << (pId + i) << " " << pPart->getPartName() << "_" << (i + 1) << " " << lPath << " " << lMEDFileName << endl;
        }
        
@@ -911,6 +918,8 @@ void MeshDis::writeDistributedMED(const char* pMEDfilenamePrefix)
                strMasterFilename = strPrefix + strExtension;
        }
        
+       string strDestPath = multipr::getPath(strMasterFilename.c_str());
+       
        MULTIPR_LOG("Create master: " << strMasterFilename << endl);
        strcpy(mMEDfilename, strMasterFilename.c_str());
        
@@ -947,6 +956,17 @@ void MeshDis::writeDistributedMED(const char* pMEDfilenamePrefix)
                        {
                                mParts[itPart]->mId = id;
                                id++;
+                               
+                               // copy file in another directory?
+                               string strSrcPath = multipr::getPath(mParts[itPart]->getMEDFileName());
+                               if (strSrcPath != strDestPath)
+                               {
+                                       cout << "Write: KEEP_AS_IT: copy file" << endl;
+                                       string strDestFilename = strDestPath + multipr::getFilenameWithoutPath(mParts[itPart]->getMEDFileName());
+                                       multipr::copyFile(mParts[itPart]->getMEDFileName(), strDestPath.c_str());
+                                       strcpy(mParts[itPart]->mMEDFileName, strDestFilename.c_str());
+                               }
+                               
                                fileMaster << (*mParts[itPart]) << endl;
                                cout << (*mParts[itPart]) << endl;
                                break;
@@ -956,6 +976,10 @@ void MeshDis::writeDistributedMED(const char* pMEDfilenamePrefix)
                        {
                                if (strlen(mParts[itPart]->getMEDFileName()) == 0) throw IOException("MED filename is empty", __FILE__, __LINE__);
                                if (mParts[itPart]->mMesh == NULL) throw IllegalStateException("invalid mesh (shoult not be NULL)", __FILE__, __LINE__);
+                               
+                               string strDestFilename = strDestPath + multipr::getFilenameWithoutPath(mParts[itPart]->getMEDFileName());
+                               strcpy(mParts[itPart]->mMEDFileName, strDestFilename.c_str());
+                               
                                mParts[itPart]->mMesh->writeMED(mParts[itPart]->getMEDFileName());
                                mParts[itPart]->mId = id;
                                id++;
@@ -973,7 +997,7 @@ void MeshDis::writeDistributedMED(const char* pMEDfilenamePrefix)
                                sprintf(tmpFilename, "%s_part", strPrefix.c_str());
                                mParts[itPart]->mCollection->write(tmpFilename);
                                mParts[itPart]->mCollection->castAllFields(*(mParts[itPart]->mOldCollection));
-                               int ret = convertMedsplitterToMultipr(fileMaster, tmpFilename, id, mParts[itPart]);
+                               int ret = convertMedsplitterToMultipr(fileMaster, tmpFilename, id, mParts[itPart], strDestPath);
                                id += ret;
                                remove(mParts[itPart]->getMEDFileName());
                                break;