size += sizeof( myWorkClassifiers[0] ) * myWorkClassifiers.size();
if ( size > 1e+9 ) // 1G
{
-#ifdef _DEBUG_
+
+ if (SALOME::VerbosityActivated())
std::cout << "Avoid ElementsOnShape::clone(), too large: " << size << " bytes " << std::endl;
-#endif
+
return 0;
}
#include "SMESH_Comment.hxx"
-//#define _DEBUG_
#include <utilities.h>
using namespace std;
myErrorMessages.push_back( msg );
MESSAGE(msg);
-#ifdef _DEBUG_
- cout << msg << endl;
-#endif
+
return ( myStatus = isFatal ? DRS_FAIL : DRS_WARN_SKIP_ELEM );
}
// File : DriverCGNS_Read.cxx
// Created : Thu Jun 30 10:33:31 2011
// Author : Edward AGAPOV (eap)
-//#define _DEBUG_
+
#include <utilities.h>
#include "DriverCGNS_Read.hxx"
//#include <stdlib.h>
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-//#define _DEXCEPT_
-#else
-static int MYDEBUG = 0;
-#endif
-
#define _EDF_NODE_IDS_
using namespace MED;
try {
#endif
myFamilies.clear();
- if(MYDEBUG) MESSAGE("Perform - myFile : "<<myFile);
+ MESSAGE("Perform - myFile : "<<myFile);
PWrapper aMed = CrWrapperR(myFile);
aResult = DRS_EMPTY;
if (myMeshId != -1) aMeshName = SMESH_Comment( myMeshId );
else aMeshName = myMeshName;
-
if(MYDEBUG) MESSAGE("Perform - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
+ MESSAGE("Perform - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
if ( aMeshName != aMeshInfo->GetName() ) continue;
aResult = DRS_OK;
//------------------------------------------------
TErr anErr;
TInt aNbFams = aMed->GetNbFamilies(aMeshInfo);
- if(MYDEBUG) MESSAGE("Read " << aNbFams << " families");
+ MESSAGE("Read " << aNbFams << " families");
for (TInt iFam = 0; iFam < aNbFams; iFam++)
{
PFamilyInfo aFamilyInfo = aMed->GetPFamilyInfo(aMeshInfo,iFam+1,&anErr);
if(anErr >= 0){
TInt aFamId = aFamilyInfo->GetId();
- if(MYDEBUG) MESSAGE("Family " << aFamId << " :");
+ MESSAGE("Family " << aFamId << " :");
DriverMED_FamilyPtr aFamily (new DriverMED_Family);
TInt aNbGrp = aFamilyInfo->GetNbGroup();
- if(MYDEBUG) MESSAGE("belong to " << aNbGrp << " groups");
+ MESSAGE("belong to " << aNbGrp << " groups");
bool isAttrOk = false;
if(aFamilyInfo->GetNbAttr() == aNbGrp)
isAttrOk = true;
TInt anAttrVal = aFamilyInfo->GetAttrVal(iGr);
aFamily->SetGroupAttributVal(anAttrVal);
}
- if(MYDEBUG) MESSAGE(aGroupName);
+ MESSAGE(aGroupName);
if ( strncmp( aGroupName.c_str(), NIG_GROUP_PREFIX, strlen(NIG_GROUP_PREFIX) ) != 0 )
aFamily->AddGroupName( fixUTF8( aGroupName ));
}
EBooleen anIsNodeNum = aNodeInfo->IsElemNum();
TInt aNbElems = aNodeInfo->GetNbElem();
-
if(MYDEBUG) MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum);
+ MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems<<"; anIsNodeNum = "<<anIsNodeNum);
DriverMED_FamilyPtr aFamily;
for ( TInt iElem = 0; iElem < aNbElems; iElem++ )
{
PCellInfo aCellInfo = aMed->GetPCellInfo(aMeshInfo,anEntity,aGeom);
EBooleen anIsElemNum = takeNumbers ? aCellInfo->IsElemNum() : eFAUX;
TInt aNbElems = aCellInfo->GetNbElem();
-
if(MYDEBUG) MESSAGE("Perform - anEntity = "<<anEntity<<"; anIsElemNum = "<<anIsElemNum);
-
if(MYDEBUG) MESSAGE("Perform - aGeom = "<<aGeom<<"; aNbElems = "<<aNbElems);
+ MESSAGE("Perform - anEntity = "<<anEntity<<"; anIsElemNum = "<<anIsElemNum);
+ MESSAGE("Perform - aGeom = "<<aGeom<<"; aNbElems = "<<aNbElems);
TInt aNbNodes = -1;
switch(aGeom){
aResult = DRS_WARN_DESCENDING;
}
-
if(MYDEBUG) MESSAGE("Perform - aResult status = "<<aResult);
+ MESSAGE("Perform - aResult status = "<<aResult);
return aResult;
}
list<string> aMeshNames;
try {
- if(MYDEBUG) MESSAGE("GetMeshNames - myFile : " << myFile);
+ MESSAGE("GetMeshNames - myFile : " << myFile);
theStatus = DRS_OK;
PWrapper aMed = CrWrapperR(myFile);
}
const char* aGroupName = theGroup->GetStoreName();
- if(MYDEBUG) MESSAGE("Get Group " << aGroupName);
+ MESSAGE("Get Group " << aGroupName);
if (( famVecPtr = myGroups2FamiliesMap.ChangeSeek( aGroupName )))
{
using namespace std;
-
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
namespace
{
/*!
using namespace UNV2411;
TDataSet aDataSet2411;
UNV2411::Read(in_stream,aDataSet2411);
-
if(MYDEBUG) MESSAGE("Perform - aDataSet2411.size() = "<<aDataSet2411.size());
+ MESSAGE("Perform - aDataSet2411.size() = "<<aDataSet2411.size());
// Move nodes in a global CS
if ( !aCoordSysDataSet.empty() )
TDataSet aDataSet2412;
UNV2412::Read(in_stream,aDataSet2412);
TDataSet::const_iterator anIter = aDataSet2412.begin();
-
if(MYDEBUG) MESSAGE("Perform - aDataSet2412.size() = "<<aDataSet2412.size());
+ MESSAGE("Perform - aDataSet2412.size() = "<<aDataSet2412.size());
for(; anIter != aDataSet2412.end(); anIter++)
{
SMDS_MeshElement* anElement = NULL;
using namespace UNV2417;
TDataSet aDataSet2417;
UNV2417::Read(in_stream,aDataSet2417);
-
if(MYDEBUG) MESSAGE("Perform - aDataSet2417.size() = "<<aDataSet2417.size());
+ MESSAGE("Perform - aDataSet2417.size() = "<<aDataSet2417.size());
if (aDataSet2417.size() > 0)
{
TDataSet::const_iterator anIter = aDataSet2417.begin();
#include "MED_Wrapper.hxx"
#include "MED_Utilities.hxx"
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-static int MYVALUEDEBUG = 0;
-#else
-// static int MYDEBUG = 0;
-// static int MYVALUEDEBUG = 0;
-#endif
-
namespace MED
{
//---------------------------------------------------------------
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo)
{
- MSG(MYDEBUG,"GetElemsByEntity(...)");
+ MSG("GetElemsByEntity(...)");
TEntity2TGeom2ElemInfo anEntity2TGeom2ElemInfo;
MED::TEntityInfo::const_iterator anIter = theEntityInfo.begin();
PElemInfo anElemInfo;
aGeom2ElemInfo[aGeom] = theWrapper->GetPElemInfo(theMeshInfo,anEntity,aGeom,MED::eNOD,&anErr);
}
}
- ADDMSG(MYDEBUG,"\n");
+ ADDMSG("\n");
return anEntity2TGeom2ElemInfo;
}
GetFamilyInfoSet(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo)
{
- MSG(MYDEBUG,"GetFamilies(...)");
+ MSG("GetFamilies(...)");
TErr anErr;
TFamilyInfoSet aFamilyInfoSet;
TInt aNbFam = theWrapper->GetNbFamilies(*theMeshInfo);
- INITMSG(
MYDEBUG,"GetNbFamilies() = "<<aNbFam<<"\n");
+ INITMSG("GetNbFamilies() = "<<aNbFam<<"\n");
for(TInt iFam = 1; iFam <= aNbFam; iFam++){
PFamilyInfo aFamilyInfo = theWrapper->GetPFamilyInfo(theMeshInfo,iFam,&anErr);
if(anErr >= 0)
aFamilyInfoSet.insert(aFamilyInfo);
}
- ADDMSG(MYDEBUG,"\n");
+ ADDMSG("\n");
return aFamilyInfoSet;
}
TGroupInfo
GetGroupInfo(const TFamilyInfoSet& theFamilyInfoSet)
{
- MSG(MYDEBUG,"GetFamiliesByGroup(...)");
+ MSG("GetFamiliesByGroup(...)");
TGroupInfo aGroup;
TFamilyInfoSet::const_iterator anIter = theFamilyInfoSet.begin();
for(; anIter != theFamilyInfoSet.end(); anIter++){
}
}
-#ifdef _DEBUG_
- if(MYDEBUG){
+ if(SALOME::VerbosityActivated()){
TGroupInfo::const_iterator anIter = aGroup.begin();
for(; anIter != aGroup.end(); anIter++){
const std::string& aName = anIter->first;
- INITMSG(
MYDEBUG,"aGroupName = '"<<aName<<"'\n");
+ INITMSG("aGroupName = '"<<aName<<"'\n");
const TFamilyInfoSet& aFamilyInfoSet = anIter->second;
TFamilyInfoSet::const_iterator anFamIter = aFamilyInfoSet.begin();
for(; anFamIter != aFamilyInfoSet.end(); anFamIter++){
const PFamilyInfo& aFamilyInfo = *anFamIter;
- INITMSG(
MYDEBUG,"aFamilyName = '"<<aFamilyInfo->GetName()<<"'\n");
+ INITMSG("aFamilyName = '"<<aFamilyInfo->GetName()<<"'\n");
}
}
- ADDMSG(MYDEBUG,"\n");
+ ADDMSG("\n");
}
-#endif
return aGroup;
}
const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo)
{
- MSG(MYDEBUG,"GetFieldsByEntity(...)");
+ MSG("GetFieldsByEntity(...)");
TFieldInfo2TimeStampInfoSet aFieldInfo2TimeStampInfoSet;
TInt aNbFields = theWrapper->GetNbFields();
- INITMSG(
MYDEBUG,"GetNbFields() = "<<aNbFields<<"\n");
+ INITMSG("GetNbFields() = "<<aNbFields<<"\n");
for(TInt iField = 1; iField <= aNbFields; iField++){
PFieldInfo aFieldInfo = theWrapper->GetPFieldInfo(theMeshInfo,iField);
- INITMSG(
MYDEBUG,"aFieldName = '"<<aFieldInfo->GetName()<<
+ INITMSG("aFieldName = '"<<aFieldInfo->GetName()<<
"'; aNbComp = "<<aFieldInfo->GetNbComp()<<"; ");
TGeom2Size aGeom2Size;
EEntiteMaillage anEntity = EEntiteMaillage(-1);
TInt aNbTimeStamps = theWrapper->GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom2Size);
- ADDMSG(
MYDEBUG,"anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
+ ADDMSG("anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
for(TInt iTimeStamp = 1; iTimeStamp <= aNbTimeStamps; iTimeStamp++){
PTimeStampInfo aTimeStamp =
theWrapper->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp);
aFieldInfo2TimeStampInfoSet[aFieldInfo].insert(aTimeStamp);
- INITMSG(MYDEBUG,
- "aDt = "<<aTimeStamp->GetDt()<<
- ", Unit = \'"<<aTimeStamp->GetUnitDt()<<"\n");
+ INITMSG("aDt = "<<aTimeStamp->GetDt()<<", Unit = \'"<<aTimeStamp->GetUnitDt()<<"\n");
}
}
- ADDMSG(MYDEBUG,"\n");
+ ADDMSG("\n");
return aFieldInfo2TimeStampInfoSet;
}
const TEntity2TGeom2ElemInfo& theEntity2TGeom2ElemInfo,
const TFamilyInfoSet& theFamilyInfoSet)
{
- MSG(MYDEBUG,"GetFamiliesByEntity(...)");
+ MSG("GetFamiliesByEntity(...)");
TEntity2FamilySet anEntity2FamilySet;
typedef std::map<TInt,PFamilyInfo> TId2Family;
TEntity2FamilyID::const_iterator anIter = anEntity2FamilyID.begin();
for(; anIter != anEntity2FamilyID.end(); anIter++){
const EEntiteMaillage& anEntity = anIter->first;
- INITMSG(
MYDEBUG,"anEntity = "<<anEntity<<":\n");
+ INITMSG("anEntity = "<<anEntity<<":\n");
const TFamilyID2Size& aFamilyID2Size = anIter->second;
TFamilyID2Size::const_iterator anIter2 = aFamilyID2Size.begin();
for(; anIter2 != aFamilyID2Size.end(); anIter2++){
if(anIter3 != anId2Family.end()){
const PFamilyInfo& aFamilyInfo = anIter3->second;
anEntity2FamilySet[anEntity].insert(TFamilyTSize(aFamilyInfo,aSize));
- INITMSG(MYDEBUG,
- "aFamilyName = '"<<aFamilyInfo->GetName()<<
+ INITMSG("aFamilyName = '"<<aFamilyInfo->GetName()<<
"' anId = "<<aFamilyInfo->GetId()<<"\n");
}
}
}
}
}
- ADDMSG(MYDEBUG,"\n");
+ ADDMSG("\n");
return anEntity2FamilySet;
}
TErr* theErr,
EModeSwitch theMode)
{
- INITMSG(MYDEBUG,"GetKey2Gauss - theMode = "<<theMode<<std::endl);
+ INITMSG("GetKey2Gauss - theMode = "<<theMode<<std::endl);
TKey2Gauss aKey2Gauss;
TInt aNbGauss = theWrapper->GetNbGauss(theErr);
for(TInt anId = 1; anId <= aNbGauss; anId++){
TGaussInfo::TKey aKey = boost::get<0>(aPreInfo);
aKey2Gauss[aKey] = anInfo;
-#ifdef _DEBUG_
- const EGeometrieElement& aGeom = boost::get<0>(aKey);
- const std::string& aName = boost::get<1>(aKey);
- INITMSG(MYDEBUG,
- "- aGeom = "<<aGeom<<
- "; aName = '"<<aName<<"'"<<
- std::endl);
-#endif
-
+ if (SALOME::VerbosityActivated())
+ {
+ const EGeometrieElement& aGeom = boost::get<0>(aKey);
+ const std::string& aName = boost::get<1>(aKey);
+ INITMSG("- aGeom = "<<aGeom<<"; aName = '"<<aName<<"'"<<std::endl);
+ }
}
+
return aKey2Gauss;
}
TErr* theErr,
EModeProfil theMode)
{
- INITMSG(MYDEBUG,"GetMKey2Profile - theMode = "<<theMode<<std::endl);
+ INITMSG("GetMKey2Profile - theMode = "<<theMode<<std::endl);
TKey2Profile aKey2Profile;
TInt aNbProfiles = theWrapper->GetNbProfiles(theErr);
for(TInt anId = 1; anId <= aNbProfiles; anId++){
const std::string& aName = boost::get<0>(aPreInfo);
aKey2Profile[aName] = anInfo;
-#ifdef _DEBUG_
- INITMSG(MYDEBUG,
- "- aName = '"<<aName<<"'"<<
- " : "<<
- std::endl);
- TInt aNbElem = anInfo->GetSize();
- for(TInt iElem = 0; iElem < aNbElem; iElem++){
- ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", ");
- }
- ADDMSG(MYVALUEDEBUG, std::endl);
-#endif
+ if(SALOME::VerbosityActivated()){
+ INITMSG("- aName = '"<<aName<<"'"<<" : "<<std::endl);
+ TInt aNbElem = anInfo->GetSize();
+ for(TInt iElem = 0; iElem < aNbElem; iElem++){
+ ADDMSG(anInfo->GetElemNum(iElem)<<", ");
+ }
+
+ ADDMSG(std::endl);
+ }
}
return TMKey2Profile(theMode,aKey2Profile);
}
#include "MED_GaussUtils.hxx"
#include "MED_Utilities.hxx"
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-static int MYVALUEDEBUG = 0;
-#else
-// static int MYDEBUG = 0; // unused in release mode
-// static int MYVALUEDEBUG = 0; // unused in release mode
-#endif
-
namespace MED
{
//---------------------------------------------------------------
{
TInt aNbRef = theRefCoord.size();
TInt aNbRef2 = GetNbRef();
- INITMSG(MYDEBUG,"TShapeFun::IsSatisfy "<<
+ INITMSG("TShapeFun::IsSatisfy "<<
"- aNbRef("<<aNbRef<<")"<<
"; aNbRef2("<<aNbRef2<<")\n");
bool anIsSatisfy = (aNbRef == aNbRef2);
}
}
if(!anIsEqual){
-#ifdef _DEBUG_
- TCCoordSlice aCoord = GetCoord(aRefId);
- INITMSG(MYDEBUG,aRefId + 1<<": aCoord = {");
- TInt aDim = aCoord.size();
- for(TInt anId = 0; anId < aDim; anId++)
-
ADDMSG(MYDEBUG,"\t"<<aCoord[anId]);
- const TCCoordSlice& aCoord2 = theRefCoord[aRefId];
- ADDMSG(MYDEBUG,"}\t!=\taCoord2 = {");
- for(TInt anId = 0; anId < aDim; anId++)
-
ADDMSG(MYDEBUG,"\t"<<aCoord2[anId]);
- ADDMSG(MYDEBUG,"}\n");
-#endif
-#ifndef _DEBUG_
- BEGMSG(
MYDEBUG,"anIsSatisfy = "<<anIsSatisfy<<"\n");
+ if(SALOME::VerbosityActivated()){
+ TCCoordSlice aCoord = GetCoord(aRefId);
+ INITMSG(aRefId + 1<<": aCoord = {");
+ TInt aDim = aCoord.size();
+ for(TInt anId = 0; anId < aDim; anId++)
+
ADDMSG("\t"<<aCoord[anId]);
+ const TCCoordSlice& aCoord2 = theRefCoord[aRefId];
+ ADDMSG("}\t!=\taCoord2 = {");
+ for(TInt anId = 0; anId < aDim; anId++)
+
ADDMSG("\t"<<aCoord2[anId]);
+ ADDMSG("}\n");
+ }
+
+ BEGMSG("anIsSatisfy = "<<anIsSatisfy<<"\n");
return anIsSatisfy;
-#endif
}
}
}
- BEGMSG(
MYDEBUG,"anIsSatisfy = "<<anIsSatisfy<<"\n");
+ BEGMSG("anIsSatisfy = "<<anIsSatisfy<<"\n");
return anIsSatisfy;
}
TGaussCoord& theGaussCoord,
EModeSwitch theMode)
{
- INITMSG(MYDEBUG,"TShapeFun::Eval"<<std::endl);
+ INITMSG("TShapeFun::Eval"<<std::endl);
if(IsSatisfy(theRef)){
const PMeshInfo& aMeshInfo = theCellInfo.GetMeshInfo();
InitFun(theRef,theGauss,aFun);
TInt aConnDim = theCellInfo.GetConnDim();
- INITMSG(
MYDEBUG,"aDim = "<<aDim<<
+ INITMSG("aDim = "<<aDim<<
"; aNbGauss = "<<aNbGauss<<
"; aNbElem = "<<aNbElem<<
"; aNbNodes = "<<theNodeInfo.GetNbElem()<<
}
}
-#ifdef _DEBUG_
+ if (SALOME::VerbosityActivated())
{
- INITMSG(MYVALUEDEBUG,"theGauss: ");
+ INITMSG("theGauss: ");
for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
TCCoordSlice aCoordSlice = theGauss[aGaussId];
- ADDMSG(MYVALUEDEBUG,"{");
+ ADDMSG("{");
for(TInt aDimId = 0; aDimId < aDim; aDimId++){
- ADDMSG(MYVALUEDEBUG,aCoordSlice[aDimId]<<" ");
+ ADDMSG(aCoordSlice[aDimId]<<" ");
}
- ADDMSG(MYVALUEDEBUG,"} ");
+ ADDMSG("} ");
}
- ADDMSG(MYVALUEDEBUG,std::endl);
- }
- for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
- TCCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
- INITMSG(MYVALUEDEBUG,"");
- for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
- TCCoordSlice aCoordSlice = aCoordSliceArr[aGaussId];
- ADDMSG(MYVALUEDEBUG,"{");
- for(TInt aDimId = 0; aDimId < aDim; aDimId++){
- ADDMSG(MYVALUEDEBUG,aCoordSlice[aDimId]<<" ");
+ ADDMSG(std::endl);
+
+ for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+ TCCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
+ INITMSG("");
+ for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+ TCCoordSlice aCoordSlice = aCoordSliceArr[aGaussId];
+ ADDMSG("{");
+ for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+ ADDMSG(aCoordSlice[aDimId]<<" ");
+ }
+ ADDMSG("} ");
}
- ADDMSG(MYVALUEDEBUG,"} ");
+ ADDMSG(std::endl);
}
- ADDMSG(MYVALUEDEBUG,std::endl);
}
-#endif
+
return true;
}
const TElemNum& theElemNum,
EModeSwitch theMode)
{
- INITMSG(MYDEBUG,"GetGaussCoord3D\n");
+ INITMSG("GetGaussCoord3D\n");
if(theGaussInfo.myGeom == theCellInfo.myGeom){
EGeometrieElement aGeom = theGaussInfo.myGeom;
switch(aGeom){
case eSEG2: {
- INITMSG(MYDEBUG,"eSEG2"<<std::endl);
+ INITMSG("eSEG2"<<std::endl);
if(TSeg2a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eSEG3: {
- INITMSG(MYDEBUG,"eSEG3"<<std::endl);
+ INITMSG("eSEG3"<<std::endl);
if(TSeg3a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eTRIA3: {
- INITMSG(MYDEBUG,"eTRIA3"<<std::endl);
+ INITMSG("eTRIA3"<<std::endl);
if(TTria3a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eTRIA6: {
- INITMSG(MYDEBUG,"eTRIA6"<<std::endl);
+ INITMSG("eTRIA6"<<std::endl);
if(TTria6a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eQUAD4: {
- INITMSG(MYDEBUG,"eQUAD4"<<std::endl);
+ INITMSG("eQUAD4"<<std::endl);
if(TQuad4a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eQUAD8: {
- INITMSG(MYDEBUG,"eQUAD8"<<std::endl);
+ INITMSG("eQUAD8"<<std::endl);
if(TQuad8a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eQUAD9: {
- INITMSG(MYDEBUG,"eQUAD9"<<std::endl);
+ INITMSG("eQUAD9"<<std::endl);
if(TQuad9a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eTETRA4: {
- INITMSG(MYDEBUG,"eTETRA4"<<std::endl);
+ INITMSG("eTETRA4"<<std::endl);
if(TTetra4a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case ePYRA5: {
- INITMSG(MYDEBUG,"ePYRA5"<<std::endl);
+ INITMSG("ePYRA5"<<std::endl);
if(TPyra5a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case ePENTA6: {
- INITMSG(MYDEBUG,"ePENTA6"<<std::endl);
+ INITMSG("ePENTA6"<<std::endl);
if(TPenta6a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eHEXA8: {
- INITMSG(MYDEBUG,"eHEXA8"<<std::endl);
+ INITMSG("eHEXA8"<<std::endl);
if(THexa8a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eTETRA10: {
- INITMSG(MYDEBUG,"eTETRA10"<<std::endl);
+ INITMSG("eTETRA10"<<std::endl);
if(TTetra10a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case ePYRA13: {
- INITMSG(MYDEBUG,"ePYRA13"<<std::endl);
+ INITMSG("ePYRA13"<<std::endl);
if(TPyra13a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case ePENTA15: {
- INITMSG(MYDEBUG,"ePENTA15"<<std::endl);
+ INITMSG("ePENTA15"<<std::endl);
if(TPenta15a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
case eHEXA20: {
- INITMSG(MYDEBUG,"eHEXA20"<<std::endl);
+ INITMSG("eHEXA20"<<std::endl);
if(THexa20a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
return true;
break;
}
default:
- INITMSG(MYDEBUG,"eNONE"<<std::endl);
+ INITMSG("eNONE"<<std::endl);
return false;
}
}
const TElemNum& theElemNum,
EModeSwitch theMode)
{
- INITMSG(MYDEBUG,"GetBaryCenter\n");
+ INITMSG("GetBaryCenter\n");
const PMeshInfo& aMeshInfo = theCellInfo.GetMeshInfo();
TInt aDim = aMeshInfo->GetDim();
static TInt aNbGauss = 1;
TInt aConnDim = theCellInfo.GetConnDim();
- INITMSGA(MYDEBUG,0,
+ INITMSGA(0,
"- aDim = "<<aDim<<
"; aNbGauss = "<<aNbGauss<<
"; aNbElem = "<<aNbElem<<
}
}
-#ifdef _DEBUG_
- for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
- TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
- INITMSG(MYVALUEDEBUG,"");
- for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
- TCoordSlice& aCoordSlice = aCoordSliceArr[aGaussId];
- ADDMSG(MYVALUEDEBUG,"{");
- for(TInt aDimId = 0; aDimId < aDim; aDimId++){
- ADDMSG(MYVALUEDEBUG,aCoordSlice[aDimId]<<" ");
+ if (SALOME::VerbosityActivated())
+ {
+ for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
+ TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
+ INITMSG("");
+ for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
+ TCoordSlice& aCoordSlice = aCoordSliceArr[aGaussId];
+ ADDMSG("{");
+ for(TInt aDimId = 0; aDimId < aDim; aDimId++){
+ ADDMSG(aCoordSlice[aDimId]<<" ");
+ }
+ ADDMSG("} ");
}
- ADDMSG(MYVALUEDEBUG,"} ");
+ ADDMSG(std::endl);
}
- ADDMSG(MYVALUEDEBUG,std::endl);
}
-#endif
return true;
}
const TElemNum& theElemNum,
EModeSwitch theMode)
{
- INITMSG(MYDEBUG,"GetBaryCenter\n");
+ INITMSG("GetBaryCenter\n");
const PMeshInfo& aMeshInfo = thePolygoneInfo.GetMeshInfo();
TInt aDim = aMeshInfo->GetDim();
static TInt aNbGauss = 1;
theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);
- INITMSGA(MYDEBUG,0,
+ INITMSGA(0,
"- aDim = "<<aDim<<
"; aNbGauss = "<<aNbGauss<<
"; aNbElem = "<<aNbElem<<
const TElemNum& theElemNum,
EModeSwitch theMode)
{
- INITMSG(MYDEBUG,"GetBaryCenter\n");
+ INITMSG("GetBaryCenter\n");
const PMeshInfo& aMeshInfo = thePolyedreInfo.GetMeshInfo();
TInt aDim = aMeshInfo->GetDim();
static TInt aNbGauss = 1;
theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);
- INITMSGA(MYDEBUG,0,
+ INITMSGA(0,
"- aDim = "<<aDim<<
"; aNbGauss = "<<aNbGauss<<
"; aNbElem = "<<aNbElem<<
#include <valarray>
#include <stdexcept>
-//#if defined(_DEBUG_)
# define MED_TCSLICE_CHECK_RANGE
-//#endif
namespace MED
{
#include "MED_Utilities.hxx"
#include "MED_Common.hxx"
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-//static int MYDEBUG = 0; // unused in release mode
-#endif
-
int MED::PrefixPrinter::myCounter = 0;
MED::PrefixPrinter::PrefixPrinter(bool theIsActive):
{
if(myIsActive)
myCounter++;
- MSG(MYDEBUG,"MED::PrefixPrinter::PrefixPrinter(...)- "<<myCounter);
+
+ MSG("MED::PrefixPrinter::PrefixPrinter(...)- "<<myCounter);
}
MED::PrefixPrinter::~PrefixPrinter() noexcept(false)
#define MED_Utilities_HeaderFile
#include "MED_WrapperDef.hxx"
+#include "utilities.h"
#include <iostream>
#include <sstream>
};
}
-#ifdef _DEBUG_
- #define MSG(deb,msg) if(deb) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg<<" ("<<__FILE__<<" ["<<__LINE__<<"])\n"
- #define BEGMSG(deb,msg) if(deb) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg
- #define INITMSGA(deb,lev,msg) MED::PrefixPrinter aPrefixPrinter_##lev(deb); BEGMSG(deb,msg)
- #define INITMSG(deb,msg) INITMSGA(deb,,msg)
- #define ADDMSG(deb,msg) if(deb) std::cout<<msg
-#else // _DEBUG_
- #define MSG(deb,msg)
- #define BEGMSG(deb,msg)
- #define INITMSGA(deb,lev,msg)
- #define INITMSG(deb,msg)
- #define ADDMSG(deb,msg)
-#endif // _DEBUG_
+#define MSG(msg) if(SALOME::VerbosityActivated()) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg<<" ("<<__FILE__<<" ["<<__LINE__<<"])\n"; else (void)0
+#define BEGMSG(msg) if(SALOME::VerbosityActivated()) std::cout<<MED::PrefixPrinter::GetPrefix()<<msg; else (void)0
+#define INITMSGA(lev,msg) if(SALOME::VerbosityActivated()) { MED::PrefixPrinter aPrefixPrinter_##lev(true); BEGMSG(msg); } else (void)0
+#define INITMSG(msg) INITMSGA(,msg)
+#define ADDMSG(msg) if(SALOME::VerbosityActivated()) std::cout<<msg; else (void)0
#ifndef EXCEPTION
#include <vector>
#include <stdexcept>
-//#if defined(_DEBUG_)
# define MED_TVECTOR_CHECK_RANGE
-//#endif
namespace MED
{
#include <boost/version.hpp>
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-static int MYVALUEDEBUG = 0;
-#else
-// static int MYDEBUG = 0; // unused in release mode
-// static int MYVALUEDEBUG = 0; // unused in release mode
-#endif
-
namespace MED
{
//---------------------------------------------------------------
#else
boost::detail::thread::lock_ops<TWrapper::TMutex>::lock(myWrapper->myMutex);
#endif
- INITMSG(MYDEBUG, "TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
+ INITMSG("TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
}
TLockProxy
::~TLockProxy()
{
- INITMSG(MYDEBUG, "~TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
+ INITMSG("~TLockProxy() - this -"<<this<<"; myWrapper = "<<myWrapper<<std::endl);
#if BOOST_VERSION >= 103500
myWrapper->myMutex.unlock();
#else
void
Print(SharedPtr<TimeStampValueType> theTimeStampValue)
{
- INITMSG(MYDEBUG,"Print - TimeStampValue\n");
+ INITMSG("Print - TimeStampValue\n");
typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValue->myGeom2Value;
typename TimeStampValueType::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
for (; anIter != aGeom2Value.end(); anIter++) {
TInt aNbElem = aMeshValue.myNbElem;
TInt aNbGauss = aMeshValue.myNbGauss;
TInt aNbComp = aMeshValue.myNbComp;
- INITMSG(
MYDEBUG, "aGeom = "<<aGeom<<" - "<<aNbElem<<": ");
+ INITMSG("aGeom = "<<aGeom<<" - "<<aNbElem<<": ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
typename TimeStampValueType::TTMeshValue::TCValueSliceArr aValueSliceArr =
aMeshValue.GetGaussValueSliceArr(iElem);
- ADDMSG(MYVALUEDEBUG, "{");
+ ADDMSG("{");
for (TInt iGauss = 0; iGauss < aNbGauss; iGauss++) {
const typename TimeStampValueType::TTMeshValue::TCValueSlice& aValueSlice =
aValueSliceArr[iGauss];
for (TInt iComp = 0; iComp < aNbComp; iComp++) {
- ADDMSG(MYVALUEDEBUG, aValueSlice[iComp]<<" ");
+ ADDMSG(aValueSlice[iComp]<<" ");
}
- ADDMSG(MYVALUEDEBUG, "| ");
+ ADDMSG("| ");
}
- ADDMSG(MYVALUEDEBUG, "} ");
+ ADDMSG("} ");
}
- ADDMSG(MYDEBUG, "\n");
+ ADDMSG("\n");
}
}
//if (aRet == 0)
// aRet = MEDunvCr(myFile->Id(),&aMeshName);
- INITMSG(
MYDEBUG, "TWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
+ INITMSG("TWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
if (theErr)
*theErr = aRet;
aNbGroup,
&aGroupNames);
- INITMSG(
MYDEBUG, "TWrapper::SetFamilyInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
+ INITMSG("TWrapper::SetFamilyInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
if (theErr)
*theErr = aRet;
PFamilyInfo anInfo = CrFamilyInfo(theMeshInfo, aNbGroup, aNbAttr);
GetFamilyInfo(theId, *anInfo, theErr);
-#ifdef _DEBUG_
- std::string aName = anInfo->GetName();
- INITMSG(MYDEBUG, "GetPFamilyInfo - aFamilyName = '"<<aName<<
- "'; andId = "<<anInfo->GetId()<<
- "; aNbAttr = "<<aNbAttr<<
- "; aNbGroup = "<<aNbGroup<<"\n");
- for (TInt iGroup = 0; iGroup < aNbGroup; iGroup++) {
- aName = anInfo->GetGroupName(iGroup);
- INITMSG(MYDEBUG, "aGroupName = '"<<aName<<"'\n");
+ if (SALOME::VerbosityActivated())
+ {
+ std::string aName = anInfo->GetName();
+ INITMSG("GetPFamilyInfo - aFamilyName = '"<<aName<<
+ "'; andId = "<<anInfo->GetId()<<
+ "; aNbAttr = "<<aNbAttr<<
+ "; aNbGroup = "<<aNbGroup<<"\n");
+ for (TInt iGroup = 0; iGroup < aNbGroup; iGroup++) {
+ aName = anInfo->GetGroupName(iGroup);
+ INITMSG("aGroupName = '"<<aName<<"'\n");
+ }
}
-#endif
return anInfo;
}
PNodeInfo anInfo = CrNodeInfo(theMeshInfo, aNbElems);
GetNodeInfo(*anInfo, theErr);
-#ifdef _DEBUG_
- TInt aDim = theMeshInfo->myDim;
- TInt aNbElem = anInfo->GetNbElem();
- INITMSG(MYDEBUG, "GetPNodeInfo: ");
+ if (SALOME::VerbosityActivated())
{
- INITMSG(MYDEBUG, "aCoords: "<<aNbElem<<": ");
- TNodeCoord& aCoord = anInfo->myCoord;
- for (TInt iElem = 0; iElem < aNbElem; iElem++) {
- for (TInt iDim = 0, anId = iElem*aDim; iDim < aDim; iDim++, anId++) {
- ADDMSG(MYVALUEDEBUG, aCoord[anId]<<",");
+ TInt aDim = theMeshInfo->myDim;
+ TInt aNbElem = anInfo->GetNbElem();
+ INITMSG("GetPNodeInfo: ");
+ {
+ INITMSG("aCoords: "<<aNbElem<<": ");
+ TNodeCoord& aCoord = anInfo->myCoord;
+ for (TInt iElem = 0; iElem < aNbElem; iElem++) {
+ for (TInt iDim = 0, anId = iElem*aDim; iDim < aDim; iDim++, anId++) {
+ ADDMSG(aCoord[anId]<<",");
+ }
+ ADDMSG(" ");
}
- ADDMSG(MYVALUEDEBUG, " ");
- }
- ADDMSG(MYDEBUG, std::endl);
-
- BEGMSG(MYVALUEDEBUG, "GetFamNum: ");
- for (TInt iElem = 0; iElem < aNbElem; iElem++) {
- ADDMSG(MYVALUEDEBUG, anInfo->GetFamNum(iElem)<<", ");
- }
- ADDMSG(MYVALUEDEBUG, std::endl);
+ ADDMSG(std::endl);
- if (anInfo->IsElemNum()) {
- BEGMSG(MYVALUEDEBUG, "GetElemNum: ");
+ BEGMSG("GetFamNum: ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
- ADDMSG(MYVALUEDEBUG, anInfo->GetElemNum(iElem)<<", ");
+ ADDMSG(anInfo->GetFamNum(iElem)<<", ");
+ }
+ ADDMSG(std::endl);
+
+ if (anInfo->IsElemNum()) {
+ BEGMSG("GetElemNum: ");
+ for (TInt iElem = 0; iElem < aNbElem; iElem++) {
+ ADDMSG(anInfo->GetElemNum(iElem)<<", ");
+ }
+ ADDMSG(std::endl);
}
- ADDMSG(MYVALUEDEBUG, std::endl);
}
+ ADDMSG(std::endl);
}
- ADDMSG(MYDEBUG, std::endl);
-#endif
return anInfo;
}
PPolygoneInfo anInfo = CrPolygoneInfo(theMeshInfo, theEntity, theGeom, aNbElem, aConnSize, theConnMode);
GetPolygoneInfo(anInfo);
-#ifdef _DEBUG_
- INITMSG(MYDEBUG, "GetPPolygoneInfo"<<
- " - theGeom = "<<theGeom<<
- "; aNbElem = "<<aNbElem<<": ");
- for (TInt iElem = 1; iElem < aNbElem; iElem++) {
- TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
- TInt aConnDim = aConnSlice.size();
- for (TInt iConn = 0; iConn < aConnDim; iConn++) {
- ADDMSG(MYVALUEDEBUG, aConnSlice[iConn]<<",");
+ if (SALOME::VerbosityActivated())
+ {
+ INITMSG("GetPPolygoneInfo"<<
+ " - theGeom = "<<theGeom<<
+ "; aNbElem = "<<aNbElem<<": ");
+ for (TInt iElem = 1; iElem < aNbElem; iElem++) {
+ TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
+ TInt aConnDim = aConnSlice.size();
+ for (TInt iConn = 0; iConn < aConnDim; iConn++) {
+ ADDMSG(aConnSlice[iConn]<<",");
+ }
+ ADDMSG(" ");
}
- ADDMSG(MYDEBUG, " ");
+ ADDMSG(std::endl);
}
- ADDMSG(MYDEBUG, std::endl);
-#endif
return anInfo;
}
PPolyedreInfo anInfo = CrPolyedreInfo(theMeshInfo, theEntity, theGeom, aNbElem, aNbFaces, aConnSize, theConnMode);
GetPolyedreInfo(anInfo);
-#ifdef _DEBUG_
- INITMSG(MYDEBUG, "GetPPolyedreInfo"<<
- " - theGeom = "<<theGeom<<
- "; aNbElem = "<<aNbElem<<": ");
- for (TInt iElem = 0; iElem < aNbElem; iElem++) {
- TCConnSliceArr aConnSliceArr = anInfo->GetConnSliceArr(iElem);
- TInt aNbFaces = aConnSliceArr.size();
- ADDMSG(MYDEBUG, "{");
- for (TInt iFace = 0; iFace < aNbFaces; iFace++) {
- TCConnSlice aConnSlice = aConnSliceArr[iFace];
- TInt aNbConn = aConnSlice.size();
- ADDMSG(MYDEBUG, "[");
- for (TInt iConn = 0; iConn < aNbConn; iConn++) {
- ADDMSG(MYVALUEDEBUG, aConnSlice[iConn]<<",");
+ if (SALOME::VerbosityActivated())
+ {
+ INITMSG("GetPPolyedreInfo"<<
+ " - theGeom = "<<theGeom<<
+ "; aNbElem = "<<aNbElem<<": ");
+ for (TInt iElem = 0; iElem < aNbElem; iElem++) {
+ TCConnSliceArr aConnSliceArr = anInfo->GetConnSliceArr(iElem);
+ TInt aNbFaces = aConnSliceArr.size();
+ ADDMSG("{");
+ for (TInt iFace = 0; iFace < aNbFaces; iFace++) {
+ TCConnSlice aConnSlice = aConnSliceArr[iFace];
+ TInt aNbConn = aConnSlice.size();
+ ADDMSG("[");
+ for (TInt iConn = 0; iConn < aNbConn; iConn++) {
+ ADDMSG(aConnSlice[iConn]<<",");
+ }
+ ADDMSG("] ");
}
- ADDMSG(MYDEBUG, "] ");
+ ADDMSG("} ");
}
- ADDMSG(MYDEBUG, "} ");
+ ADDMSG(std::endl);
}
- ADDMSG(MYDEBUG, std::endl);
-#endif
return anInfo;
}
PCellInfo anInfo = CrCellInfo(theMeshInfo, theEntity, theGeom, aNbElem, theConnMode);
GetCellInfo(anInfo, theErr);
-#ifdef _DEBUG_
- TInt aConnDim = anInfo->GetConnDim();
- INITMSG(MYDEBUG, "GetPCellInfo - theEntity = "<<theEntity<<"; theGeom = "<<theGeom<<"; aConnDim: "<<aConnDim<<"\n");
- BEGMSG(MYDEBUG, "GetPCellInfo - aNbElem: "<<aNbElem<<": ");
- for (TInt iElem = 0; iElem < aNbElem; iElem++) {
- TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
- for (TInt iConn = 0; iConn < aConnDim; iConn++) {
- ADDMSG(MYVALUEDEBUG, aConnSlice[iConn]<<",");
+ if (SALOME::VerbosityActivated())
+ {
+ TInt aConnDim = anInfo->GetConnDim();
+ INITMSG("GetPCellInfo - theEntity = "<<theEntity<<"; theGeom = "<<theGeom<<"; aConnDim: "<<aConnDim<<"\n");
+ BEGMSG("GetPCellInfo - aNbElem: "<<aNbElem<<": ");
+ for (TInt iElem = 0; iElem < aNbElem; iElem++) {
+ TCConnSlice aConnSlice = anInfo->GetConnSlice(iElem);
+ for (TInt iConn = 0; iConn < aConnDim; iConn++) {
+ ADDMSG(aConnSlice[iConn]<<",");
+ }
+ ADDMSG(" ");
}
- ADDMSG(MYVALUEDEBUG, " ");
- }
- ADDMSG(MYDEBUG, std::endl);
-
- BEGMSG(MYVALUEDEBUG, "GetPCellInfo - GetFamNum: ");
- for (TInt iElem = 0; iElem < aNbElem; iElem++) {
- ADDMSG(MYVALUEDEBUG, anInfo->GetFamNum(iElem)<<", ");
- }
- ADDMSG(MYVALUEDEBUG, std::endl);
+ ADDMSG(std::endl);
- if (anInfo->IsElemNum()) {
- BEGMSG(MYVALUEDEBUG, "GetPCellInfo - GetElemNum: ");
+ BEGMSG("GetPCellInfo - GetFamNum: ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
- ADDMSG(MYVALUEDEBUG, anInfo->GetElemNum(iElem)<<", ");
+ ADDMSG(anInfo->GetFamNum(iElem)<<", ");
+ }
+ ADDMSG(std::endl);
+
+ if (anInfo->IsElemNum()) {
+ BEGMSG("GetPCellInfo - GetElemNum: ");
+ for (TInt iElem = 0; iElem < aNbElem; iElem++) {
+ ADDMSG(anInfo->GetElemNum(iElem)<<", ");
+ }
+ ADDMSG(std::endl);
}
- ADDMSG(MYVALUEDEBUG, std::endl);
+ ADDMSG(std::endl);
}
- ADDMSG(MYDEBUG, std::endl);
-#endif
return anInfo;
}
PFieldInfo anInfo = CrFieldInfo(theMeshInfo, aNbComp);
GetFieldInfo(theId, *anInfo, theErr);
-#ifdef _DEBUG_
- INITMSG(MYDEBUG,
- "GetPFieldInfo "<<
- "- aName = '"<<anInfo->GetName()<<"'"<<
- "; aType = "<<anInfo->GetType()<<
- "; aNbComp = "<<aNbComp<<
- std::endl);
-#endif
+ if (SALOME::VerbosityActivated())
+ {
+ INITMSG("GetPFieldInfo "<<
+
"- aName = '"<<anInfo->GetName()<<"'"<<
+
"; aType = "<<anInfo->GetType()<<
+
"; aNbComp = "<<aNbComp<<
+ std::endl);
+ }
return anInfo;
}
}
bool anIsSatisfied =(nval > 0);
if (anIsSatisfied) {
- INITMSG(MYDEBUG,
- "GetNbTimeStamps aNbTimeStamps = "<<aNbStamps<<
+ INITMSG("GetNbTimeStamps aNbTimeStamps = "<<aNbStamps<<
"; aGeom = "<<aGeom<<"; anEntity = "<<anEntity<<"\n");
if (anIsPerformAdditionalCheck) {
anIsSatisfied = !strcmp(&aMeshName[0], &aMeshInfo.myName[0]);
if (!anIsSatisfied) {
- INITMSG(MYDEBUG,
- "GetNbTimeStamps aMeshName = '"<<&aMeshName[0]<<"' != "<<
+ INITMSG("GetNbTimeStamps aMeshName = '"<<&aMeshName[0]<<"' != "<<
"; aMeshInfo.myName = '"<<&aMeshInfo.myName[0]<<"'\n");
}
}
PTimeStampInfo anInfo = CrTimeStampInfo(theFieldInfo, theEntity, theGeom2Size);
GetTimeStampInfo(theId, *anInfo, theErr);
-#ifdef _DEBUG_
- INITMSG(MYDEBUG, "GetPTimeStampInfo - anEntity = "<<anInfo->GetEntity()<<"\n");
- TGeom2NbGauss& aGeom2NbGauss = anInfo->myGeom2NbGauss;
- TGeom2NbGauss::const_iterator anIter = aGeom2NbGauss.begin();
- for (; anIter != aGeom2NbGauss.end(); anIter++) {
- const EGeometrieElement& aGeom = anIter->first;
- INITMSG(MYDEBUG, "aGeom = "<<aGeom<<" - "<<aGeom2NbGauss[aGeom]<<";\n");
+ if (SALOME::VerbosityActivated())
+ {
+ INITMSG("GetPTimeStampInfo - anEntity = "<<anInfo->GetEntity()<<"\n");
+ TGeom2NbGauss& aGeom2NbGauss = anInfo->myGeom2NbGauss;
+ TGeom2NbGauss::const_iterator anIter = aGeom2NbGauss.begin();
+ for (; anIter != aGeom2NbGauss.end(); anIter++) {
+ const EGeometrieElement& aGeom = anIter->first;
+ INITMSG("aGeom = "<<aGeom<<" - "<<aGeom2NbGauss[aGeom]<<";\n");
+ }
}
-#endif
return anInfo;
}
aNbComp);
TInt aValueSize = theTimeStampValue->GetValueSize(aGeom);
- INITMSG(MYDEBUG,
- "TWrapper::GetTimeStampValue - aGeom = "<<aGeom<<
+ INITMSG("TWrapper::GetTimeStampValue - aGeom = "<<aGeom<<
"; aNbVal = "<<aNbVal<<
"; aNbValue = "<<aNbValue<<
"; aNbGauss = "<<aNbGauss<<
}
- INITMSG(
MYDEBUG, "TWrapper::SetTimeStampValue - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
+ INITMSG("TWrapper::SetTimeStampValue - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
}
//----------------------------------------------------------------------------
theMKey2Profile,
theKey2Gauss,
theErr);
-#ifdef _DEBUG_
- if (aFieldInfo->GetType() == eFLOAT64)
- Print<TFloatTimeStampValue>(anInfo);
- else
- Print<TIntTimeStampValue>(anInfo);
-#endif
+ if (SALOME::VerbosityActivated())
+ {
+ if (aFieldInfo->GetType() == eFLOAT64)
+ Print<TFloatTimeStampValue>(anInfo);
+ else
+ Print<TIntTimeStampValue>(anInfo);
+ }
return anInfo;
}
GetGrilleInfo(anInfo);
anInfo->SetGrilleType(type);
-#ifdef _DEBUG_
- INITMSG(MYDEBUG, "GetPGrilleInfo: ");
+ if (SALOME::VerbosityActivated())
{
+ INITMSG("GetPGrilleInfo: ");
+
TInt aNbElem = anInfo->GetNbNodes();
- BEGMSG(MYVALUEDEBUG, "GetFamNumNode: ");
+ BEGMSG("GetFamNumNode: ");
for (TInt iElem = 0; iElem < aNbElem; iElem++) {
- ADDMSG(MYVALUEDEBUG, anInfo->GetFamNumNode(iElem)<<", ");
+ ADDMSG(anInfo->GetFamNumNode(iElem)<<", ");
}
TInt aNbCells = anInfo->GetNbCells();
- BEGMSG(MYVALUEDEBUG, "GetFamNum: ");
+ BEGMSG("GetFamNum: ");
for (TInt iElem = 0; iElem < aNbCells; iElem++) {
- ADDMSG(MYVALUEDEBUG, anInfo->GetFamNum(iElem)<<", ");
+ ADDMSG(anInfo->GetFamNum(iElem)<<", ");
}
- ADDMSG(MYVALUEDEBUG, std::endl);
- BEGMSG(MYVALUEDEBUG, "GetCoordName: ");
+ ADDMSG(std::endl);
+ BEGMSG("GetCoordName: ");
for (TInt iElem = 0; iElem < theMeshInfo->GetDim(); iElem++) {
- ADDMSG(MYVALUEDEBUG, anInfo->GetCoordName(iElem)<<", ");
+ ADDMSG(anInfo->GetCoordName(iElem)<<", ");
}
- ADDMSG(MYVALUEDEBUG, std::endl);
- BEGMSG(MYVALUEDEBUG, "GetCoordUnit: ");
+ ADDMSG(std::endl);
+ BEGMSG("GetCoordUnit: ");
for (TInt iElem = 0; iElem < theMeshInfo->GetDim(); iElem++) {
- ADDMSG(MYVALUEDEBUG, anInfo->GetCoordUnit(iElem)<<", ");
+ ADDMSG(anInfo->GetCoordUnit(iElem)<<", ");
}
- ADDMSG(MYVALUEDEBUG, std::endl);
-
+ ADDMSG(std::endl);
}
-#endif
return anInfo;
}
#include "utilities.h"
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
SMESH_ActorDef* SMESH_ActorDef::New(){
return new SMESH_ActorDef();
SMESH_ActorDef::SMESH_ActorDef()
{
- if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);
+ MESSAGE("SMESH_ActorDef - "<<this);
SALOME_Actor::SetVisibility(false); // avoid update of pipelines
SMESH_ActorDef::~SMESH_ActorDef()
{
- if(MYDEBUG) MESSAGE("~SMESH_ActorDef - "<<this);
+ MESSAGE("~SMESH_ActorDef - "<<this);
// Please keep the order same as one in the header file
void SMESH_ActorDef::Update()
{
- if(MYDEBUG) MESSAGE("SMESH_ActorDef::Update");
+ MESSAGE("SMESH_ActorDef::Update");
myVisualObj->Update();
}
if ( GetVisibility() )
aFilter->Update();
- if (MYDEBUG) MESSAGE(aFilter->GetOutput()->GetNumberOfCells());
+ MESSAGE(aFilter->GetOutput()->GetNumberOfCells());
}
#ifndef DISABLE_PLOT2DVIEWER
#include <vtkUnstructuredGridWriter.h>
#include <vtkUnsignedCharArray.h>
-//#ifdef _DEBUG_
-//static int MYDEBUG = 1;
-//#else
-//static int MYDEBUG = 0;
-//#endif
namespace SMESH
{
#include "utilities.h"
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
using namespace std;
SMESH_DeviceActor
::SMESH_DeviceActor()
{
- if(MYDEBUG) MESSAGE("SMESH_DeviceActor - "<<this);
+ MESSAGE("SMESH_DeviceActor - "<<this);
myIsShrinkable = false;
myIsShrunk = false;
SMESH_DeviceActor
::~SMESH_DeviceActor()
{
- if(MYDEBUG) MESSAGE("~SMESH_DeviceActor - "<<this);
+ MESSAGE("~SMESH_DeviceActor - "<<this);
myMapper->Delete();
// myPlaneCollection->Delete(); -- it is vtkSmartPointer
anID = myExtractGeometry->GetNodeObjId(theVtkID);
vtkIdType aRetID = myVisualObj->GetNodeObjId(anID);
-
if(MYDEBUG) MESSAGE("GetNodeObjId - theVtkID = "<<theVtkID<<"; anID = "<<anID<<"; aRetID = "<<aRetID);
+ MESSAGE("GetNodeObjId - theVtkID = "<<theVtkID<<"; anID = "<<anID<<"; aRetID = "<<aRetID);
return aRetID;
}
vtkDataSet* aDataSet = myMergeFilter->GetOutput();
vtkIdType anID = myVisualObj->GetNodeVTKId(theObjID);
double* aCoord = (anID >=0 && anID < aDataSet->GetNumberOfPoints()) ? aDataSet->GetPoint(anID) : NULL;
-
if(MYDEBUG) MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID);
+ MESSAGE("GetNodeCoord - theObjID = "<<theObjID<<"; anID = "<<anID);
return aCoord;
}
return -1;
vtkIdType aRetID = myVisualObj->GetElemObjId(anId3);
- if(MYDEBUG)
-
MESSAGE("GetElemObjId - theVtkID = "<<theVtkID<<"; anId2 = "<<anId2<<"; anId3 = "<<anId3<<"; aRetID = "<<aRetID);
+
+ MESSAGE("GetElemObjId - theVtkID = "<<theVtkID<<"; anId2 = "<<anId2<<"; anId3 = "<<anId3<<"; aRetID = "<<aRetID);
return aRetID;
}
vtkDataSet* aDataSet = myVisualObj->GetUnstructuredGrid();
vtkIdType aGridID = myVisualObj->GetElemVTKId(theObjID);
vtkCell* aCell = (aGridID >= 0 ) ? aDataSet->GetCell(aGridID) : NULL;
- if(MYDEBUG)
-
MESSAGE("GetElemCell - theObjID = "<<theObjID<<"; aGridID = "<<aGridID);
+
+ MESSAGE("GetElemCell - theObjID = "<<theObjID<<"; aGridID = "<<aGridID);
return aCell;
}
using namespace std;
-//#ifdef _DEBUG_
-//static int MYDEBUG = 0;
-//#else
-//static int MYDEBUG = 0;
-//#endif
-
#if defined __GNUC__
#if __GNUC__ == 2
#define __GNUC_2__
}
#endif
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
static int MYDEBUGWITHFILES = 0;//1;
-#else
-static int MYDEBUG = 0;
-static int MYDEBUGWITHFILES = 0;
-#endif
-
/*
Class : SMESH_VisualObjDef
//=================================================================================
SMESH_VisualObjDef::SMESH_VisualObjDef()
{
- if ( MYDEBUG ) MESSAGE("-------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
+ MESSAGE("-------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
myGrid = vtkUnstructuredGrid::New();
myLocalGrid = false;
ClearEntitiesFlags();
}
SMESH_VisualObjDef::~SMESH_VisualObjDef()
{
- if ( MYDEBUG ) MESSAGE("--------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
- if ( MYDEBUG ) MESSAGE( "myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
+ MESSAGE("--------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
+ MESSAGE( "myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
myGrid->Delete();
}
//=================================================================================
void SMESH_VisualObjDef::buildPrs(bool buildGrid)
{
- if ( MYDEBUG ) MESSAGE("---------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
+ MESSAGE("---------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
if (buildGrid)
{
myLocalGrid = true;
if (!GetMesh()->IsCompacted())
{
NulData(); // detach from the SMDS grid to allow immediate memory de-allocation in compactMesh()
- if ( MYDEBUG ) MESSAGE("*** buildPrs ==> compactMesh!");
+ MESSAGE("*** buildPrs ==> compactMesh!");
GetMesh()->CompactMesh();
if ( SMESHDS_Mesh* m = dynamic_cast<SMESHDS_Mesh*>( GetMesh() )) // IPAL53915
m->GetScript()->SetModified(false); // drop IsModified set in compactMesh()
myGrid->SetPoints( aPoints );
aPoints->Delete();
- if ( MYDEBUG )
- MESSAGE("Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints());
+ MESSAGE("Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints());
// Calculate cells size
}
}
}
- if ( MYDEBUG )
-
MESSAGE( "Update - aNbCells = "<<aNbCells<<"; aCellsSize = "<<aCellsSize );
+
+ MESSAGE( "Update - aNbCells = "<<aNbCells<<"; aCellsSize = "<<aCellsSize );
// Create cells
myClient(SalomeApp_Application::orb(),theMesh)
{
myEmptyGrid = 0;
- if ( MYDEBUG )
- MESSAGE("SMESH_MeshObj - this = "<<this<<"; theMesh->_is_nil() = "<<theMesh->_is_nil());
+
+ MESSAGE("SMESH_MeshObj - this = "<<this<<"; theMesh->_is_nil() = "<<theMesh->_is_nil());
}
//=================================================================================
//=================================================================================
SMESH_MeshObj::~SMESH_MeshObj()
{
- if ( MYDEBUG )
- MESSAGE("SMESH_MeshObj - this = "<<this<<"\n");
+ MESSAGE("SMESH_MeshObj - this = "<<this<<"\n");
if ( myEmptyGrid )
myEmptyGrid->Delete();
}
bool SMESH_MeshObj::Update( int theIsClear )
{
// Update SMDS_Mesh on client part
- if ( MYDEBUG ) MESSAGE("SMESH_MeshObj::Update " << this);
+ MESSAGE("SMESH_MeshObj::Update " << this);
if ( myClient.Update(theIsClear) || GetUnstructuredGrid()->GetNumberOfPoints()==0) {
- if ( MYDEBUG ) MESSAGE("buildPrs");
+ MESSAGE("buildPrs");
buildPrs(); // Fill unstructured grid
return true;
}
bool SMESH_MeshObj::NulData()
{
- if ( MYDEBUG ) MESSAGE ("SMESH_MeshObj::NulData() =============================================");
+ MESSAGE ("SMESH_MeshObj::NulData() =============================================");
if (!myEmptyGrid)
{
myEmptyGrid = SMDS_UnstructuredGrid::New();
//=================================================================================
SMESH_SubMeshObj::SMESH_SubMeshObj( SMESH_MeshObj* theMeshObj )
{
- if ( MYDEBUG ) MESSAGE( "SMESH_SubMeshObj - theMeshObj = " << theMeshObj );
+ MESSAGE( "SMESH_SubMeshObj - theMeshObj = " << theMeshObj );
myMeshObj = theMeshObj;
}
//=================================================================================
bool SMESH_SubMeshObj::Update( int theIsClear )
{
- if ( MYDEBUG ) MESSAGE("SMESH_SubMeshObj::Update " << this)
+ MESSAGE("SMESH_SubMeshObj::Update " << this);
bool changed = myMeshObj->Update( theIsClear );
buildPrs(true);
return changed;
: SMESH_SubMeshObj( theMeshObj ),
myGroupServer( SMESH::SMESH_GroupBase::_duplicate(theGroup) )
{
- if ( MYDEBUG ) MESSAGE("SMESH_GroupObj - theGroup->_is_nil() = "<<theGroup->_is_nil());
+ MESSAGE("SMESH_GroupObj - theGroup->_is_nil() = "<<theGroup->_is_nil());
myGroupServer->Register();
}
SMESH_GroupObj::~SMESH_GroupObj()
{
- if ( MYDEBUG ) MESSAGE("~SMESH_GroupObj");
+ MESSAGE("~SMESH_GroupObj");
myGroupServer->UnRegister();
}
: SMESH_SubMeshObj( theMeshObj ),
mySubMeshServer( SMESH::SMESH_subMesh::_duplicate( theSubMesh ) )
{
- if ( MYDEBUG ) MESSAGE( "SMESH_subMeshObj - theSubMesh->_is_nil() = " << theSubMesh->_is_nil() );
+ MESSAGE( "SMESH_subMeshObj - theSubMesh->_is_nil() = " << theSubMesh->_is_nil() );
mySubMeshServer->Register();
}
SMESH_subMeshObj::~SMESH_subMeshObj()
{
- if ( MYDEBUG ) MESSAGE( "~SMESH_subMeshObj" );
+ MESSAGE( "~SMESH_subMeshObj" );
mySubMeshServer->UnRegister();
}
#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
SMESH_PreviewActorsCollection::SMESH_PreviewActorsCollection() :
mySelector( 0 ), myRenderer( 0 ), myCurrentChunk( 0 ), myChunkSize( 0 ), myIsShown( true )
{
- if(MYDEBUG) MESSAGE("SMESH_PreviewActorsCollection - "<<this);
+ MESSAGE("SMESH_PreviewActorsCollection - "<<this);
}
SMESH_PreviewActorsCollection::~SMESH_PreviewActorsCollection()
{
- if(MYDEBUG) MESSAGE("~SMESH_PreviewActorsCollection - "<<this);
+ MESSAGE("~SMESH_PreviewActorsCollection - "<<this);
clearActors();
}
#include <sys/sysinfo.h>
#endif
-#ifdef _DEBUG_
#include <iostream>
-#endif
int main ()
{
}
} catch (...) {}
-// #ifdef _DEBUG_
-// std::cout << freeRamKb / 1024 << std::endl;
-// #endif
+// if (SALOME::VerbosityActivated())
+// std::cout << freeRamKb / 1024 << std::endl;
+
return freeRamKb / 1024;
#endif
_errorMessages.push_back( msg );
//~MESSAGE(msg);
-#ifdef _DEBUG_
- std::cout << msg << std::endl;
-#endif
+ if (SALOME::VerbosityActivated())
+ std::cout << msg << std::endl;
+
return ( _status = isFatal ? MgAdapt::DRS_FAIL : MgAdapt::DRS_WARN_SKIP_ELEM );
}
// maximum stored group name length in MED file
#define MAX_MED_GROUP_NAME_LENGTH 80
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
#define cSMESH_Hyp(h) static_cast<const SMESH_Hypothesis*>(h)
typedef SMESH_HypoFilter THypType;
SMESHDS_Document* theDocument):
_groupId( 0 ), _nbSubShapes( 0 )
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)");
+ MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)");
_id = theLocalId;
_gen = theGen;
_document = theDocument;
SMESH_Mesh::~SMESH_Mesh()
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh::~SMESH_Mesh");
+ MESSAGE("SMESH_Mesh::~SMESH_Mesh");
if ( _document ) // avoid destructing _meshDS from ~SMESH_Gen()
_document->RemoveMesh( _id );
void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh::ShapeToMesh");
+ MESSAGE("SMESH_Mesh::ShapeToMesh");
if ( !aShape.IsNull() && _isShapeToMesh ) {
if ( aShape.ShapeType() != TopAbs_COMPOUND && // group contents is allowed to change
myReader.SetFile(theFileName);
myReader.SetMeshName(theMeshName);
Driver_Mesh::Status status = myReader.Perform();
-#ifdef _DEBUG_
- SMESH_ComputeErrorPtr er = myReader.GetError();
- if ( er && !er->IsOK() ) std::cout << er->myComment << std::endl;
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ SMESH_ComputeErrorPtr er = myReader.GetError();
+ if ( er && !er->IsOK() ) std::cout << er->myComment << std::endl;
+ }
// Reading groups (sub-meshes are out of scope of MED import functionality)
std::list<TNameAndType> aGroupNames = myReader.GetGroupNamesAndTypes();
int anHypId,
std::string* anError )
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh::AddHypothesis");
+ MESSAGE("SMESH_Mesh::AddHypothesis");
if ( anError )
anError->clear();
std::string hypName = anHyp->GetName();
if ( hypName == "NotConformAllowed" )
{
- if(MYDEBUG) MESSAGE( "Hypothesis <NotConformAllowed> can be only global" );
+ MESSAGE( "Hypothesis <NotConformAllowed> can be only global" );
return SMESH_Hypothesis::HYP_INCOMPATIBLE;
}
}
HasModificationsToDiscard(); // to reset _isModified flag if a mesh becomes empty
GetMeshDS()->Modified();
- if(MYDEBUG) subMesh->DumpAlgoState(true);
- if(MYDEBUG) SCRUTE(ret);
+ if(SALOME::VerbosityActivated()) subMesh->DumpAlgoState(true);
+ SCRUTE(ret);
return ret;
}
SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
int anHypId)
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh::RemoveHypothesis");
+ MESSAGE("SMESH_Mesh::RemoveHypothesis");
StudyContextStruct *sc = _gen->GetStudyContext();
if (sc->mapHypothesis.find(anHypId) == sc->mapHypothesis.end())
throw SALOME_Exception(LOCALIZED("hypothesis does not exist"));
SMESH_Hypothesis *anHyp = sc->mapHypothesis[anHypId];
- if(MYDEBUG) { SCRUTE(anHyp->GetType()); }
+ SCRUTE(anHyp->GetType());
// shape
HasModificationsToDiscard(); // to reset _isModified flag if mesh become empty
GetMeshDS()->Modified();
- if(MYDEBUG) subMesh->DumpAlgoState(true);
- if(MYDEBUG) SCRUTE(ret);
+ if(SALOME::VerbosityActivated()) subMesh->DumpAlgoState(true);
+ SCRUTE(ret);
return ret;
}
rate = algo->GetProgress();
}
catch (...) {
-#ifdef _DEBUG_
- std::cerr << "Exception in " << algo->GetName() << "::GetProgress()" << std::endl;
-#endif
+ if (SALOME::VerbosityActivated())
+ std::cerr << "Exception in " << algo->GetName() << "::GetProgress()" << std::endl;
}
if ( 0. < rate && rate < 1.001 )
{
bool SMESH_Mesh::IsNotConformAllowed() const
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh::IsNotConformAllowed");
+ MESSAGE("SMESH_Mesh::IsNotConformAllowed");
static SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "NotConformAllowed" ));
return GetHypothesis( _meshDS->ShapeToMesh(), filter, false );
srcEdges.push_back(aMesh->FindEdge (commonNodes[0],commonNodes[1],commonNodes[2]));
else
srcEdges.push_back(aMesh->FindEdge (commonNodes[0],commonNodes[1]));
-#ifdef _DEBUG_
- if ( !srcEdges.back() )
+
+ if (SALOME::VerbosityActivated() && !srcEdges.back())
{
cout << "SMESH_MeshEditor::makeWalls(), no source edge found for a free face #"
- << iF << " of volume #" << vTool.ID() << endl;
+ << iF << " of volume #" << vTool.ID() << endl;
}
-#endif
}
}
if ( freeInd.empty() )
for ( size_t i = 0; i < new2OldNodes.size(); ++i )
if ( const SMDS_MeshNode* n = new2OldNodes[ i ].first )
{
-#ifndef _DEBUG_
- if ( n->NbInverseElements() > 0 )
-#endif
+
+ if (!SALOME::VerbosityActivated() || n->NbInverseElements() > 0 )
{
const SMDS_MeshNode* n2 =
tgtMeshDS->AddNodeWithID( n->X(), n->Y(), n->Z(), idShift + n->GetID() );
vecRef = du ^ dv;
if ( ++nbLoops > 10 )
{
-#ifdef _DEBUG_
- cout << "SMESH_MesherHelper::GetAngle(): Captured in a sigularity" << endl;
-#endif
+ if (SALOME::VerbosityActivated())
+ cout << "SMESH_MesherHelper::GetAngle(): Captured in a sigularity" << endl;
+
return angle;
}
}
mutable vector< const QLink* > _sides;
mutable bool _sideIsAdded[4]; // added in chain of links
gp_Vec _normal;
-#ifdef _DEBUG_
mutable const SMDS_MeshElement* _face;
-#endif
QFace( const vector< const QLink*>& links, const SMDS_MeshElement* face=0 );
else
_normal.SetCoord(1e-33,0,0);
-#ifdef _DEBUG_
- _face = face;
-#else
- (void)face; // unused in release mode
-#endif
+ if (SALOME::VerbosityActivated())
+ _face = face;
}
//================================================================================
/*!
if ( !myMesh->HasShapeToMesh() ) return;
SetSubShape( myMesh->GetShapeToMesh() );
-#ifdef _DEBUG_
int nbSolids = 0;
TopTools_IndexedMapOfShape solids;
TopExp::MapShapes(myShape,TopAbs_SOLID,solids);
nbSolids = solids.Extent();
-#endif
+
TopTools_MapOfShape faces; // faces not in solid or in not meshed solid
for ( TopExp_Explorer f(myShape,TopAbs_FACE,TopAbs_SOLID); f.More(); f.Next() ) {
faces.Add( f.Current() ); // not in solid
faces.Add( f.Current() ); // in not meshed solid
}
else { // fix nodes in the solid and its faces
-#ifdef _DEBUG_
MSG("FIX SOLID " << nbSolids-- << " #" << GetMeshDS()->ShapeToIndex(s.Current()));
-#endif
+
SMESH_MesherHelper h(*myMesh);
h.SetSubShape( s.Current() );
h.ToFixNodeParameters(true);
}
}
// fix nodes on geom faces
-#ifdef _DEBUG_
- int nbfaces = nbSolids;
- nbfaces = faces.Extent(); /*avoid "unused varianbles": */ nbfaces++, nbfaces--;
-#endif
+
+ int nbfaces = faces.Extent();
+
for ( TopTools_MapIteratorOfMapOfShape fIt( faces ); fIt.More(); fIt.Next() ) {
MESSAGE("FIX FACE " << nbfaces-- << " #" << GetMeshDS()->ShapeToIndex(fIt.Key()));
MSG("FIX FACE " << nbfaces-- << " #" << GetMeshDS()->ShapeToIndex(fIt.Key()));
// hasRectFaces = hasRectFaces ||
// ( volTool.GetVolumeType() == SMDS_VolumeTool::QUAD_HEXA ||
// volTool.GetVolumeType() == SMDS_VolumeTool::QUAD_PENTA );
-#ifdef _DEBUG_
- if ( nbN == 6 )
- pFace->_face = GetMeshDS()->FindFace(faceNodes[0],faceNodes[2],faceNodes[4]);
- else
- pFace->_face = GetMeshDS()->FindFace(faceNodes[0],faceNodes[2],
- faceNodes[4],faceNodes[6] );
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ if ( nbN == 6 )
+ pFace->_face = GetMeshDS()->FindFace(faceNodes[0],faceNodes[2],faceNodes[4]);
+ else
+ pFace->_face = GetMeshDS()->FindFace(faceNodes[0],faceNodes[2],
+ faceNodes[4],faceNodes[6] );
+ }
}
// collect pyramid apexes for further correction
if ( vol->NbCornerNodes() == 5 )
move = gp_Vec( XYZ((*link1)->_mediumNode), newPnt.Transformed(loc) );
if ( SMDS_FacePositionPtr nPos = (*link1)->_mediumNode->GetPosition())
nPos->SetParameters( newUV.X(), newUV.Y() );
-#ifdef _DEBUG_
- if ( (XYZ((*link1)->node1()) - XYZ((*link1)->node2())).SquareModulus() <
- move.SquareMagnitude())
+
+ if (SALOME::VerbosityActivated())
{
- gp_XY uv0 = faceHlp.GetNodeUV( face, (*link0)->_mediumNode, 0, &checkUV );
- gp_XY uv2 = faceHlp.GetNodeUV( face, (*link2)->_mediumNode, 0, &checkUV );
- MSG( "TOO LONG MOVE \t" <<
- "uv0: "<<uv0.X()<<", "<<uv0.Y()<<" \t" <<
- "uv2: "<<uv2.X()<<", "<<uv2.Y()<<" \t" <<
- "uvOld: "<<oldUV.X()<<", "<<oldUV.Y()<<" \t" <<
- "newUV: "<<newUV.X()<<", "<<newUV.Y()<<" \t");
- uv0.SetX( uv2.X() ); // avoid warning: variable set but not used
+ if ( (XYZ((*link1)->node1()) - XYZ((*link1)->node2())).SquareModulus() <
+ move.SquareMagnitude())
+ {
+ gp_XY uv0 = faceHlp.GetNodeUV( face, (*link0)->_mediumNode, 0, &checkUV );
+ gp_XY uv2 = faceHlp.GetNodeUV( face, (*link2)->_mediumNode, 0, &checkUV );
+ MSG( "TOO LONG MOVE \t" <<
+ "uv0: "<<uv0.X()<<", "<<uv0.Y()<<" \t" <<
+ "uv2: "<<uv2.X()<<", "<<uv2.Y()<<" \t" <<
+ "uvOld: "<<oldUV.X()<<", "<<oldUV.Y()<<" \t" <<
+ "newUV: "<<newUV.X()<<", "<<newUV.Y()<<" \t");
+ uv0.SetX( uv2.X() ); // avoid warning: variable set but not used
+ }
}
-#endif
(*link1)->Move( move, /*sum=*/false, /*is2dFixed=*/true );
}
MSG( "Move " << (*link1)->_mediumNode->GetID() << " following "
{
const char* name = "/tmp/shape.brep";
BRepTools::Write( s, name );
-#ifdef _DEBUG_
- std::cout << name << std::endl;
-#endif
+ if (SALOME::VerbosityActivated())
+ std::cout << name << std::endl;
}
void SMESH_Pattern::DumpPoints() const
{
-#ifdef _DEBUG_
- vector< TPoint >::const_iterator pVecIt = myPoints.begin();
- for ( int i = 0; pVecIt != myPoints.end(); pVecIt++, i++ )
- MESSAGE_ADD ( std::endl << i << ": " << *pVecIt );
-#endif
+ if (SALOME::VerbosityActivated())
+ {
+ vector< TPoint >::const_iterator pVecIt = myPoints.begin();
+ for ( int i = 0; pVecIt != myPoints.end(); pVecIt++, i++ )
+ MESSAGE_ADD ( std::endl << i << ": " << *pVecIt );
+ }
}
//=======================================================================
SMESH_Pattern::TPoint::TPoint()
{
-#ifdef _DEBUG_
- myInitXYZ.SetCoord(7,7,7);
- myInitUV.SetCoord(7.,7.);
- myInitU = 7;
- myXYZ.SetCoord(7,7,7);
- myUV.SetCoord(7.,7.);
- myU = 7;
-#endif
+ if (SALOME::VerbosityActivated())
+ {
+ myInitXYZ.SetCoord(7,7,7);
+ myInitUV.SetCoord(7.,7.);
+ myInitU = 7;
+ myXYZ.SetCoord(7,7,7);
+ myUV.SetCoord(7.,7.);
+ myU = 7;
+ }
}
//=======================================================================
}
#endif
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
namespace
{
using std::runtime_error;
mySMESHDSMesh(NULL),
mySMDSMesh(NULL)
{
- if ( MYDEBUG ) MESSAGE("SMESH_Client::SMESH_Client");
+ MESSAGE("SMESH_Client::SMESH_Client");
myMeshServer->Register();
CORBA::Boolean anIsEmbeddedMode;
GetSMESHGen(theORB,anIsEmbeddedMode);
if(anIsEmbeddedMode){
- if ( MYDEBUG ) MESSAGE("Info: The same process, update mesh by pointer ");
+ MESSAGE("Info: The same process, update mesh by pointer ");
// just set client mesh pointer to server mesh pointer
//SMESH_Mesh* aMesh = reinterpret_cast<SMESH_Mesh*>(theMesh->GetMeshPtr());
CORBA::LongLong pointeur = theMesh->GetMeshPtr();
-
if( MYDEBUG ) MESSAGE("SMESH_Client::SMESH_Client pointeur "<<pointeur);
+ MESSAGE("SMESH_Client::SMESH_Client pointeur "<<pointeur);
SMESH_Mesh* aMesh = reinterpret_cast<SMESH_Mesh*> (pointeur);
-
if ( MYDEBUG ) MESSAGE("SMESH_Client::SMESH_Client aMesh "<<aMesh);
+ MESSAGE("SMESH_Client::SMESH_Client aMesh "<<aMesh);
//if(aMesh->GetMeshDS()->IsEmbeddedMode()){
if(anIsEmbeddedMode){
mySMESHDSMesh = aMesh->GetMeshDS();
bool anIsModified = true;
if(mySMESHDSMesh)
{
- if ( MYDEBUG ) MESSAGE("Update mySMESHDSMesh");
+ MESSAGE("Update mySMESHDSMesh");
SMESHDS_Script* aScript = mySMESHDSMesh->GetScript();
anIsModified = aScript->IsModified();
aScript->SetModified(false);
}
else
{
- if ( MYDEBUG ) MESSAGE("Update CORBA");
+ MESSAGE("Update CORBA");
SMESH::log_array_var aSeq = myMeshServer->GetLog( theIsClear );
CORBA::Long aLength = aSeq->length();
anIsModified = aLength > 0;
-
if ( MYDEBUG ) MESSAGE( "Update: length of the script is "<<aLength );
+ MESSAGE( "Update: length of the script is "<<aLength );
if ( !anIsModified )
return false;
INFOS("Unknown exception was cought !!!");
}
- if ( MYDEBUG && mySMDSMesh )
+ if (mySMDSMesh )
{
MESSAGE("Update - mySMDSMesh->NbNodes() = "<<mySMDSMesh->NbNodes());
MESSAGE("Update - mySMDSMesh->Nb0DElements() = "<<mySMDSMesh->Nb0DElements());
if ( aR < 0. || aR > 1. || // PAL19395
aG < 0. || aG > 1. ||
aB < 0. || aB > 1. )
-// #ifdef _DEBUG_
-// cout << "SMESHDS_GroupBase::SetColorGroup("<<theColorGroup<<"), invalid color ignored"<<endl;
-// #endif
+// if (SALOME::VerbosityActivated())
+// cout << "SMESHDS_GroupBase::SetColorGroup("<<theColorGroup<<"), invalid color ignored"<<endl;
+
return;
Quantity_Color aColor( aR, aG, aB, Quantity_TOC_RGB );
SetColor( aColor );
}
}
catch (...) {
-#ifdef _DEBUG_
+
MESSAGE ( "Exception thrown during mesh visualization" );
-#endif
+
if ( SMDS_Mesh::CheckMemory(true) ) { // has memory to show warning?
SMESH::OnVisuException();
}
void SMESH_CreateBoundaryAn::SetCylinder()
// ------------------------------------------------------------------------
{
- MESSAGE("Debut de SetCylinder")
+ MESSAGE("Debut de SetCylinder");
gBCylindre->setVisible(1);
gBSphere->setVisible(0);
gBCone->setVisible(0);
void SMESH_CreateBoundaryAn::SetSphere()
// ------------------------------------------------------------------------
{
- MESSAGE("Debut de SetSphere")
+ MESSAGE("Debut de SetSphere");
gBCylindre->setVisible(0);
gBSphere->setVisible(1);
gBCone->setVisible(0);
void SMESH_CreateBoundaryAn::SetConeR()
// ------------------------------------------------------------------------
{
- MESSAGE("Debut de SetConeR")
+ MESSAGE("Debut de SetConeR");
//
// Stockage et conversion des valeurs si elles ont change
if ((_BoundaryAnXaxisCone != SpinBox_Cone_X1->value()) ||
(_BoundaryAnZorigCone != SpinBox_Cone_Z2->value()) ||
(_BoundaryAngle != SpinBox_Cone_V1->value()) )
{
- MESSAGE("Stockage et conversion")
+ MESSAGE("Stockage et conversion");
_BoundaryAnXaxisCone = SpinBox_Cone_X1->value() ;
_BoundaryAnYaxisCone = SpinBox_Cone_Y1->value() ;
_BoundaryAnZaxisCone = SpinBox_Cone_Z1->value() ;
void SMESH_CreateBoundaryAn::SetConeA()
// ------------------------------------------------------------------------
{
- MESSAGE("Debut de SetConeA")
+ MESSAGE("Debut de SetConeA");
// Stockage et conversion des valeurs si elles ont change
if ((_BoundaryAnXcone1 != SpinBox_Cone_X1->value()) ||
(_BoundaryAnYcone1 != SpinBox_Cone_Y1->value()) ||
(_BoundaryAnZcone2 != SpinBox_Cone_Z2->value()) ||
(_BoundaryAnRayon2 != SpinBox_Cone_V2->value()) )
{
- MESSAGE("Stockage et conversion")
+ MESSAGE("Stockage et conversion");
_BoundaryAnXcone1 = SpinBox_Cone_X1->value() ;
_BoundaryAnYcone1 = SpinBox_Cone_Y1->value() ;
_BoundaryAnZcone1 = SpinBox_Cone_Z1->value() ;
void SMESH_CreateBoundaryAn::SetCone()
// ------------------------------------------------------------------------
{
- MESSAGE("Debut de SetCone")
+ MESSAGE("Debut de SetCone");
gBCylindre->setVisible(0);
gBSphere->setVisible(0);
gBCone->setVisible(1);
void SMESH_CreateBoundaryAn::SetTore()
// ------------------------------------------------------------------------
{
- MESSAGE("Debut de SetTore")
+ MESSAGE("Debut de SetTore");
gBCylindre->setVisible(0);
gBSphere->setVisible(0);
gBCone->setVisible(0);
// par deux rayons ou avec un axe et un angle.
// Voir sfcoi1 de HOMARD
{
- MESSAGE("Debut de convertRayonAngle, option = "<<option)
+ MESSAGE("Debut de convertRayonAngle, option = "<<option);
//
// o
// ! .
_parent(parent), _aName(aName),
myHomardGen(SMESHHOMARD::HOMARD_Gen::_duplicate(myHomardGen0))
{
- MESSAGE("Constructeur") ;
+ MESSAGE("Constructeur");
setupUi(this);
setModal(modal);
InitConnect();
#define env_sep ":"
#endif // WIN32
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
namespace SMESH
{
typedef IMap<QString,HypothesisData*> THypothesisDataMap;
SMESHGUI_GenericHypothesisCreator* GetHypothesisCreator(const QString& aHypType)
{
- if(MYDEBUG) MESSAGE("Get HypothesisCreator for " << aHypType.toLatin1().data());
+ MESSAGE("Get HypothesisCreator for " << aHypType.toLatin1().data());
SMESHGUI_GenericHypothesisCreator* aCreator = 0;
// 3. Load Client Plugin Library
try {
// load plugin library
- if(MYDEBUG) MESSAGE("Loading client meshers plugin library ...");
+ MESSAGE("Loading client meshers plugin library ...");
#ifdef WIN32
#ifdef UNICODE
LPTSTR path = new TCHAR[aClientLibName.length() + 1];
}
else {
// get method, returning hypothesis creator
- if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ...");
+ MESSAGE("Find GetHypothesisCreator() method ...");
typedef SMESHGUI_GenericHypothesisCreator* (*GetHypothesisCreator) \
( const QString& );
GetHypothesisCreator procHandle =
(GetHypothesisCreator)GetProc(libHandle, "GetHypothesisCreator");
if (!procHandle) {
- if(MYDEBUG) MESSAGE("bad hypothesis client plugin library");
+ MESSAGE("bad hypothesis client plugin library");
UnLoadLib(libHandle);
}
else {
// get hypothesis creator
- if(MYDEBUG) MESSAGE("Get Hypothesis Creator for " << aHypType.toLatin1().data());
+ MESSAGE("Get Hypothesis Creator for " << aHypType.toLatin1().data());
aCreator = procHandle( aHypType );
if (!aCreator) {
- if(MYDEBUG) MESSAGE("no such a hypothesis in this plugin");
+ MESSAGE("no such a hypothesis in this plugin");
}
else {
// map hypothesis creator to a hypothesis name
const QString& aHypName,
const bool /*isAlgo*/)
{
- if(MYDEBUG) MESSAGE("Create " << aHypType.toLatin1().data() <<
+ MESSAGE("Create " << aHypType.toLatin1().data() <<
" with name " << aHypName.toLatin1().data());
HypothesisData* aHypData = GetHypothesisData(aHypType);
QString aServLib = aHypData->ServerLibName;
bool AddHypothesisOnMesh (SMESH::SMESH_Mesh_ptr aMesh, SMESH::SMESH_Hypothesis_ptr aHyp)
{
- if(MYDEBUG) MESSAGE ("SMESHGUI::AddHypothesisOnMesh");
+ MESSAGE ("SMESHGUI::AddHypothesisOnMesh");
int res = SMESH::HYP_UNKNOWN_FATAL;
SUIT_OverrideCursor wc;
bool AddHypothesisOnSubMesh (SMESH::SMESH_subMesh_ptr aSubMesh, SMESH::SMESH_Hypothesis_ptr aHyp)
{
- if(MYDEBUG) MESSAGE("SMESHGUI::AddHypothesisOnSubMesh() ");
+ MESSAGE("SMESHGUI::AddHypothesisOnSubMesh() ");
int res = SMESH::HYP_UNKNOWN_FATAL;
SUIT_OverrideCursor wc;
if (SO_Hypothesis) {
SObjectList listSO = SMESH::getStudy()->FindDependances(SO_Hypothesis);
- if(MYDEBUG) MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): dependency number ="<<listSO.size());
+ MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): dependency number ="<<listSO.size());
for (unsigned int i = 0; i < listSO.size(); i++) {
_PTR(SObject) SO = listSO[i];
if (SO) {
if (aFather) {
_PTR(SObject) SOfatherFather = aFather->GetFather();
if (SOfatherFather) {
- if(MYDEBUG) MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): dependency added to list");
+ MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): dependency added to list");
index++;
listSOmesh.resize(index);
listSOmesh[index - 1] = SOfatherFather;
}
}
}
- if (MYDEBUG) MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): completed");
+ MESSAGE("SMESHGUI::GetMeshesUsingAlgoOrHypothesis(): completed");
return listSOmesh;
}
theEdges.begin(), ++theEdges.begin());
TopExp::Vertices( theEdges.front(), vv[0], vv[1], true );
if ( iE++ > theNbEdgesInWires.back() ) {
-#ifdef _DEBUG_
- gp_Pnt p = BRep_Tool::Pnt( theFirstVertex );
- MESSAGE ( " : Warning : vertex "<< theFirstVertex.TShape().operator->()
- << " ( " << p.X() << " " << p.Y() << " " << p.Z() << " )"
- << " not found in outer wire of face "<< theFace.TShape().operator->()
- << " with vertices: " );
- wExp.Init( *wlIt, theFace );
- for ( int i = 0; wExp.More(); wExp.Next(), i++ )
+
+ if (SALOME::VerbosityActivated())
{
- TopoDS_Edge edge = wExp.Current();
- edge = TopoDS::Edge( edge.Oriented( wExp.Orientation() ));
- TopoDS_Vertex v = TopExp::FirstVertex( edge, true );
- gp_Pnt p = BRep_Tool::Pnt( v );
- MESSAGE_ADD ( i << " " << v.TShape().operator->() << " "
- << p.X() << " " << p.Y() << " " << p.Z() << " " << std::endl );
+ gp_Pnt p = BRep_Tool::Pnt( theFirstVertex );
+ MESSAGE ( " : Warning : vertex "<< theFirstVertex.TShape().operator->()
+ << " ( " << p.X() << " " << p.Y() << " " << p.Z() << " )"
+ << " not found in outer wire of face "<< theFace.TShape().operator->()
+ << " with vertices: " );
+ wExp.Init( *wlIt, theFace );
+ for ( int i = 0; wExp.More(); wExp.Next(), i++ )
+ {
+ TopoDS_Edge edge = wExp.Current();
+ edge = TopoDS::Edge( edge.Oriented( wExp.Orientation() ));
+ TopoDS_Vertex v = TopExp::FirstVertex( edge, true );
+ gp_Pnt p = BRep_Tool::Pnt( v );
+ MESSAGE_ADD ( i << " " << v.TShape().operator->() << " "
+ << p.X() << " " << p.Y() << " " << p.Z() << " " << std::endl );
+ }
}
-#endif
+
break; // break infinite loop
}
}
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
-#ifdef _DEBUG_
-//#define _MYDEBUG_
#include "SMESH_File.hxx"
#include "SMESH_Comment.hxx"
-#endif
+#include "utilities.h"
using namespace std;
using boost::polygon::x;
// }
// -------------------------------------------------------------------------------------
-#ifdef _MYDEBUG_
+
// writes segments into a txt file readable by voronoi_visualizer
void inSegmentsToFile( vector< InSegment>& inSegments)
{
- if ( inSegments.size() > 1000 )
+ if (inSegments.size() > 1000 || !SALOME::VerbosityActivated())
return;
+
const char* fileName = "/misc/dn25/salome/eap/salome/misc/Code/C++/MAdebug.txt";
const char* user = getenv("USER");
if ( !user || strcmp( user, "eap" )) return;
} while (edge != cell->incident_edge());
}
}
-#else
- #define inSegmentsToFile(arg) {}
- //void dumpEdge( const TVDEdge* edge ) {}
- //void dumpCell( const TVDCell* cell ) {}
-#endif
}
// -------------------------------------------------------------------------------------
void bndSegsToMesh( const vector< vector< BndSeg > >& bndSegsPerEdge )
{
- if ( bndSegsPerEdge.empty() )
+ if (bndSegsPerEdge.empty() || !SALOME::VerbosityActivated())
return;
-#ifdef _MYDEBUG_
+
if ( !getenv("bndSegsToMesh")) return;
map< const TVDVertex *, int > v2Node;
map< const TVDVertex *, int >::iterator v2n;
text << "\n";
file.write( text.c_str(), text.size() );
cout << fileName << endl;
-#endif
}
//================================================================================
buffer[length] = '\0';
infile.read(const_cast<char *>( buffer.get() ),length);
- MESSAGE( buffer.get() )
+ MESSAGE( buffer.get() );
}
{
SMESH_File redirectFile( redirect, /*open=*/false );
TElementBoxPool& elBoPool = getLimitAndPool()->_elBoPool;
-#ifdef _DEBUG_
- if ( theElemIt && !theElemIt->more() )
+ if (SALOME::VerbosityActivated() && theElemIt && !theElemIt->more() )
std::cout << "WARNING: ElementBndBoxTree constructed on empty iterator!" << std::endl;
-#endif
SMDS_ElemIteratorPtr elemIt = theElemIt ? theElemIt : mesh.elementsIterator( elemType );
while ( elemIt->more() )
{
if ( nodes[i] == nodes[i+1] || nodes[i] == nodes[i+2] || nodes[i+1] == nodes[i+2] )
{
-#ifdef _DEBUG_
- std::cerr << "BAD tria" << std::endl;
- cf.Dump();
-#else
- if ( i < 0 ) cf.Dump(); // avoid "CutFace::Dump() unused in release mode"
-#endif
+ if (SALOME::VerbosityActivated())
+ {
+ std::cerr << "BAD tria" << std::endl;
+ cf.Dump();
+ }
+ else
+ {
+ if ( i < 0 ) cf.Dump(); // avoid "CutFace::Dump() unused in release mode"
+ }
continue;
}
if (!( tria = myMesh->FindFace( nodes[i], nodes[i+1], nodes[i+2] )))
void SMESH::printErrorInDebugMode(const char* txt)
{
-#ifdef _DEBUG_
- std::cerr << txt << " " << __FILE__ << ": " << __LINE__ << std::endl;
-#else
- (void)txt; // unused in release mode
-#endif
+ if (SALOME::VerbosityActivated())
+ std::cerr << txt << " " << __FILE__ << ": " << __LINE__ << std::endl;
}
// ------------------------------------------------------------------
"Geom_POLYHEDRA", "Geom_BALL" };
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];
-#ifdef _DEBUG_
- // is types complete? (compilation failure means that enum GeometryType changed)
- static_assert( sizeof(types) / sizeof(const char*) == nbTypes,
- "Update names of GeometryType's!!!" );
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ // is types complete? (compilation failure means that enum GeometryType changed)
+ static_assert( sizeof(types) / sizeof(const char*) == nbTypes,
+ "Update names of GeometryType's!!!" );
+ }
}
if (Type == "SMESH.FT_EntityType")
{
"Entity_Polyhedra", "Entity_Quad_Polyhedra", "Entity_Ball" };
if ( -1 < iGeom && iGeom < nbTypes )
Threshold = SMESH + types[ iGeom ];
-#ifdef _DEBUG_
- // is 'types' complete? (compilation failure means that enum EntityType changed)
- static_assert( sizeof(types) / sizeof(const char*) == nbTypes,
- "Update names of EntityType's!!!" );
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ // is 'types' complete? (compilation failure means that enum EntityType changed)
+ static_assert( sizeof(types) / sizeof(const char*) == nbTypes,
+ "Update names of EntityType's!!!" );
+ }
}
}
if ( ThresholdID.Length() != 2 ) // neither '' nor ""
#define NUM_TMP_FILES 2
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
// Static variables definition
GEOM::GEOM_Gen_var SMESH_Gen_i::myGeomGen;
CORBA::ORB_var SMESH_Gen_i::myOrb;
thePlatformLibName = aPlatformLibName;
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "Create Hypothesis <" << theHypName << "> from " << aPlatformLibName);
+ MESSAGE( "Create Hypothesis <" << theHypName << "> from " << aPlatformLibName);
typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char* );
GenericHypothesisCreator_i* aCreator;
if (myHypCreatorMap.find(string(theHypName)) == myHypCreatorMap.end())
{
// load plugin library
- if(MYDEBUG) MESSAGE("Loading server meshers plugin library ...");
+ MESSAGE("Loading server meshers plugin library ...");
#ifdef WIN32
# ifdef UNICODE
const wchar_t* path = Kernel_Utils::decode_s(aPlatformLibName);
}
// get method, returning hypothesis creator
- if(MYDEBUG) MESSAGE("Find GetHypothesisCreator() method ...");
+ MESSAGE("Find GetHypothesisCreator() method ...");
GetHypothesisCreator procHandle =
(GetHypothesisCreator)GetProc( libHandle, "GetHypothesisCreator" );
if (!procHandle)
}
// get hypothesis creator
- if(MYDEBUG) MESSAGE("Get Hypothesis Creator for " << theHypName);
+ MESSAGE("Get Hypothesis Creator for " << theHypName);
aCreator = procHandle(theHypName);
if (!aCreator)
{
// activate the CORBA servant of hypothesis
hypothesis_i = myHypothesis_i->_this();
int nextId = RegisterObject( hypothesis_i );
- if(MYDEBUG) { MESSAGE( "Add hypo to map with id = "<< nextId ); }
- else { (void)nextId; } // avoid "unused variable" warning in release mode
+ MESSAGE( "Add hypo to map with id = "<< nextId );
}
return hypothesis_i._retn();
}
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
+ MESSAGE( "SMESH_Gen_i::createMesh" );
// Get or create the GEOM_Client instance
try {
// create a new mesh object servant, store it in a map in study context
SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this );
// create a new mesh object
- if(MYDEBUG) MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
+ MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
meshServant->SetImpl( myGen.CreateMesh( myIsEmbeddedMode ));
// activate the CORBA servant of Mesh
SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( meshServant->_this() );
int nextId = RegisterObject( mesh );
- if(MYDEBUG) { MESSAGE( "Add mesh to map with id = "<< nextId); }
- else { (void)nextId; } // avoid "unused variable" warning in release mode
+ MESSAGE( "Add mesh to map with id = "<< nextId);
+
return mesh._retn();
}
catch (SALOME_Exception& S_ex) {
if (!envNoCatchSignals || !atoi(envNoCatchSignals))
{
bool raiseFPE;
-#ifdef _DEBUG_
- raiseFPE = true;
- char* envDisableFPE = getenv("DISABLE_FPE");
- if (envDisableFPE && atoi(envDisableFPE))
+
+ if (SALOME::VerbosityActivated())
+ {
+ raiseFPE = true;
+ char* envDisableFPE = getenv("DISABLE_FPE");
+ if (envDisableFPE && atoi(envDisableFPE))
+ raiseFPE = false;
+ }
+ else
+ {
raiseFPE = false;
-#else
- raiseFPE = false;
-#endif
+ }
+
OSD::SetSignal( raiseFPE );
}
// else OSD::SetSignal() is called in GUI
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
+ MESSAGE( "SMESH_Gen_i::CreateMesh" );
// create mesh
SMESH::SMESH_Mesh_var mesh = this->createMesh();
// set shape
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
+ MESSAGE( "SMESH_Gen_i::CreateMesh" );
// create mesh
SMESH::SMESH_Mesh_var mesh = this->createMesh();
GEOM::GEOM_Object_ptr theShapeObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
+ MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
if ( CORBA::is_nil( theShapeObject ) )
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
GEOM::GEOM_Object_ptr theSubObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
+ MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
CORBA::Short theSubShapeID )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
+ MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
if ( CORBA::is_nil( theMesh ) )
THROW_SALOME_CORBA_EXCEPTION( "bad Mesh reference",SALOME::BAD_PARAM );
GEOM::GEOM_Object_ptr theSubObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
+ MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
if ( CORBA::is_nil( theSubObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
const SMESH::object_array& theListOfSubShapeObject )
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
+ MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
SMESH::long_array_var shapesId = new SMESH::long_array;
set<int> setId;
{
const TopoDS_Face& F = TopoDS::Face(exp.Current());
setId.insert(myIndexToShape.FindIndex(F));
- if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(F));
+ SCRUTE(myIndexToShape.FindIndex(F));
}
for (TopExp_Explorer exp(locShape,TopAbs_EDGE); exp.More(); exp.Next())
{
const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
setId.insert(myIndexToShape.FindIndex(E));
- if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(E));
+ SCRUTE(myIndexToShape.FindIndex(E));
}
for (TopExp_Explorer exp(locShape,TopAbs_VERTEX); exp.More(); exp.Next())
{
const TopoDS_Vertex& V = TopoDS::Vertex(exp.Current());
setId.insert(myIndexToShape.FindIndex(V));
- if(MYDEBUG) SCRUTE(myIndexToShape.FindIndex(V));
+ SCRUTE(myIndexToShape.FindIndex(V));
}
}
shapesId->length(setId.size());
int i=0;
for (iind = setId.begin(); iind != setId.end(); iind++)
{
- if(MYDEBUG) SCRUTE((*iind));
+ SCRUTE((*iind));
shapesId[i] = (*iind);
- if(MYDEBUG) SCRUTE(shapesId[i]);
+ SCRUTE(shapesId[i]);
i++;
}
}
{
//MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Compute" );
+ MESSAGE( "SMESH_Gen_i::Compute" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
SMESH::long_array& theShapesId)
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
+ MESSAGE( "SMESH_Gen_i::Precompute" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference",
GEOM::GEOM_Object_ptr theShapeObject)
{
Unexpect aCatch(SALOME_SalomeException);
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
+ MESSAGE( "SMESH_Gen_i::Evaluate" );
if ( CORBA::is_nil( theShapeObject ) && theMesh->HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
if (PyErr_Occurred()) {
// Restrieving python error
- MESSAGE("Catching error")
+ MESSAGE("Catching error");
PyObject *errtype, *errvalue, *traceback;
PyErr_Fetch(&errtype, &errvalue, &traceback);
if(errvalue != NULL) {
- MESSAGE("Error has a value")
+ MESSAGE("Error has a value");
PyObject *s = PyObject_Str(errvalue);
Py_ssize_t size;
std::string msg = PyUnicode_AsUTF8AndSize(s, &size);
msg = "Issue with the execution of create_dual_mesh:\n"+msg;
- MESSAGE("throwing exception")
+ MESSAGE("throwing exception");
// We need to deactivate the GIL before throwing the exception
PyGILState_Release(gstate);
THROW_SALOME_CORBA_EXCEPTION(msg.c_str(), SALOME::INTERNAL_ERROR );
SALOMEDS::TMPFile* SMESH_Gen_i::SaveASCII( SALOMEDS::SComponent_ptr theComponent,
const char* theURL,
bool isMultiFile ) {
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::SaveASCII" );
+ MESSAGE( "SMESH_Gen_i::SaveASCII" );
SALOMEDS::TMPFile_var aStreamFile = Save( theComponent, theURL, isMultiFile );
return aStreamFile._retn();
size = aDataset->GetSize();
char* libname_str = new char[ size ];
aDataset->ReadFromDisk( libname_str );
- if(MYDEBUG) SCRUTE( libname_str );
+ SCRUTE( libname_str );
libname = string( libname_str );
delete [] libname_str;
aDataset->CloseOnDisk();
// --> restore hypothesis from data
if ( id > 0 && !hypname.empty()/* && !hypdata.empty()*/ ) { // VSR : persistent data can be empty
- if(MYDEBUG) MESSAGE("VSR - load hypothesis : id = " << id <<
+ MESSAGE("VSR - load hypothesis : id = " << id <<
", name = " << hypname.c_str() << ", persistent string = " << hypdata.c_str());
SMESH::SMESH_Hypothesis_var myHyp;
myStudyContext->mapOldToNew( id, newId );
}
else
- if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
+ MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
}
}
}
size = aDataset->GetSize();
char* libname_str = new char[ size ];
aDataset->ReadFromDisk( libname_str );
- if(MYDEBUG) SCRUTE( libname_str );
+ SCRUTE( libname_str );
libname = string( libname_str );
delete [] libname_str;
aDataset->CloseOnDisk();
size = aDataset->GetSize();
char* hypdata_str = new char[ size ];
aDataset->ReadFromDisk( hypdata_str );
- if(MYDEBUG) SCRUTE( hypdata_str );
+ SCRUTE( hypdata_str );
hypdata = string( hypdata_str );
delete [] hypdata_str;
aDataset->CloseOnDisk();
// --> restore algorithm from data
if ( id > 0 && !hypname.empty()/* && !hypdata.empty()*/ ) { // VSR : persistent data can be empty
- if(MYDEBUG) MESSAGE("VSR - load algo : id = " << id <<
+ MESSAGE("VSR - load algo : id = " << id <<
", name = " << hypname.c_str() << ", persistent string = " << hypdata.c_str());
SMESH::SMESH_Hypothesis_var myHyp;
myStudyContext->mapOldToNew( id, newId );
}
else
- if(MYDEBUG) MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
+ MESSAGE( "VSR - SMESH_Gen::Load - can't get servant" );
}
}
}
int aNbObjects = aTopGroup->nInternalObjects();
if ( aNbObjects > 0 ) {
// create mesh
- if(MYDEBUG) MESSAGE( "VSR - load mesh : id = " << id );
+ MESSAGE( "VSR - load mesh : id = " << id );
SMESH::SMESH_Mesh_var myNewMesh = this->createMesh();
SMESH_Mesh_i* myNewMeshImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( myNewMesh ).in() );
if ( !myNewMeshImpl )
aGroup->OpenOnDisk();
// get number of applied algorithms
int aNbSubObjects = aGroup->nInternalObjects();
- if(MYDEBUG) MESSAGE( "VSR - number of applied algos " << aNbSubObjects );
+ MESSAGE( "VSR - number of applied algos " << aNbSubObjects );
for ( int j = 0; j < aNbSubObjects; j++ ) {
char name_dataset[ HDF_NAME_MAX_LEN+1 ];
aGroup->InternalObjectIndentify( j, name_dataset );
const SALOMEDS::TMPFile& theStream,
const char* theURL,
bool isMultiFile ) {
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::LoadASCII" );
+ MESSAGE( "SMESH_Gen_i::LoadASCII" );
return Load( theComponent, theStream, theURL, isMultiFile );
//before call main ::Load method it's need for decipher text format to
void SMESH_Gen_i::Close( SALOMEDS::SComponent_ptr theComponent )
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Close" );
+ MESSAGE( "SMESH_Gen_i::Close" );
// Clear study contexts data
myStudyContext->Clear();
char* SMESH_Gen_i::ComponentDataType()
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::ComponentDataType" );
+ MESSAGE( "SMESH_Gen_i::ComponentDataType" );
return CORBA::string_dup( "SMESH" );
}
CORBA::Boolean /*isMultiFile*/,
CORBA::Boolean /*isASCII*/ )
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IORToLocalPersistentID" );
+ MESSAGE( "SMESH_Gen_i::IORToLocalPersistentID" );
if ( myStudyContext && strcmp( IORString, "" ) != 0 ) {
int anId = myStudyContext->findId( IORString );
if ( anId ) {
- if(MYDEBUG) MESSAGE( "VSR " << anId )
+ MESSAGE( "VSR " << anId );
char strId[ 20 ];
sprintf( strId, "%d", anId );
return CORBA::string_dup( strId );
CORBA::Boolean /*isMultiFile*/,
CORBA::Boolean /*isASCII*/ )
{
- if(MYDEBUG) MESSAGE( "SMESH_Gen_i::LocalPersistentIDToIOR(): id = " << aLocalPersistentID );
+ MESSAGE( "SMESH_Gen_i::LocalPersistentIDToIOR(): id = " << aLocalPersistentID );
if ( myStudyContext && strcmp( aLocalPersistentID, "" ) != 0 ) {
int anId = atoi( aLocalPersistentID );
SMESH_CATCH( SMESH::doNothing );
-#ifdef _DEBUG_
- cout << "SMESH_Gen_i::IsApplicable(): exception in " << ( theAlgoType ? theAlgoType : "") << endl;
-#endif
+ if (SALOME::VerbosityActivated())
+ cout << "SMESH_Gen_i::IsApplicable(): exception in " << ( theAlgoType ? theAlgoType : "") << endl;
+
return true;
}
#include <cctype>
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
using namespace std;
//=============================================================================
bool SMESH_Gen_i::CanPublishInStudy(CORBA::Object_ptr theIOR)
{
- if(MYDEBUG) MESSAGE("CanPublishInStudy - "<<!CORBA::is_nil(getStudyServant()));
+ MESSAGE("CanPublishInStudy - "<<!CORBA::is_nil(getStudyServant()));
if ( !myIsEnablePublish )
return false;
if( !aGroup->_is_nil() )
return true;
- if(MYDEBUG) MESSAGE("CanPublishInStudy--CANT");
+ MESSAGE("CanPublishInStudy--CANT");
return false;
}
return aSO._retn();
if ( CORBA::is_nil( theIOR ))
return aSO._retn();
- if(MYDEBUG) MESSAGE("PublishInStudy");
+ MESSAGE("PublishInStudy");
// Publishing a mesh
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( theIOR );
aMesh = aGroup->GetMesh();
aSO = PublishGroup( aMesh, aGroup, aShapeObject, theName );
}
- if(MYDEBUG) MESSAGE("PublishInStudy_END");
+ MESSAGE("PublishInStudy_END");
return aSO._retn();
}
SALOMEDS::SComponent_ptr SMESH_Gen_i::PublishComponent()
{
- if(MYDEBUG) MESSAGE("PublishComponent");
+ MESSAGE("PublishComponent");
if ( !myIsEnablePublish )
return SALOMEDS::SComponent::_nil();
// (to support tree representation customization and drag-n-drop)
useCaseBuilder->SetRootCurrent();
useCaseBuilder->Append( father ); // component object is added as the top level item
- if(MYDEBUG) MESSAGE("PublishComponent--END");
+ MESSAGE("PublishComponent--END");
return father._retn();
}
return SALOMEDS::SObject::_nil();
if ( CORBA::is_nil( theMesh ))
return SALOMEDS::SObject::_nil();
- if(MYDEBUG) MESSAGE("PublishMesh--IN");
+ MESSAGE("PublishMesh--IN");
// find or publish a mesh
}
}
- if(MYDEBUG) MESSAGE("PublishMesh_END");
+ MESSAGE("PublishMesh_END");
return aMeshSO._retn();
}
SMESH_Gen_i::PublishHypothesis (SMESH::SMESH_Hypothesis_ptr theHyp,
const char* theName)
{
- if(MYDEBUG) MESSAGE("PublishHypothesis");
+ MESSAGE("PublishHypothesis");
if ( !myIsEnablePublish )
return SALOMEDS::SObject::_nil();
if (theHyp->_is_nil())
SetName( aHypSO, theName, hypType.in() );
- if(MYDEBUG) MESSAGE("PublishHypothesis--END")
+ MESSAGE("PublishHypothesis--END");
return aHypSO._retn();
}
SMESH_Gen_i::GetMeshOrSubmeshByShape (SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShape)
{
- if(MYDEBUG) MESSAGE("GetMeshOrSubmeshByShape")
+ MESSAGE("GetMeshOrSubmeshByShape");
SALOMEDS::SObject_wrap aMeshOrSubMesh;
if (theMesh->_is_nil() || ( theShape->_is_nil() && theMesh->HasShapeToMesh()))
return aMeshOrSubMesh._retn();
aMeshOrSubMesh = ObjectToSObject( aSubMesh );
}
}
- if(MYDEBUG) MESSAGE("GetMeshOrSubmeshByShape--END")
+ MESSAGE("GetMeshOrSubmeshByShape--END");
return aMeshOrSubMesh._retn();
}
GEOM::GEOM_Object_ptr theShape,
SMESH::SMESH_Hypothesis_ptr theHyp)
{
- if(MYDEBUG) MESSAGE("AddHypothesisToShape")
+ MESSAGE("AddHypothesisToShape");
if (theMesh->_is_nil() ||
theHyp->_is_nil() || (theShape->_is_nil()
&& theMesh->HasShapeToMesh()) )
addReference( AHR, theHyp );
- if(MYDEBUG) MESSAGE("AddHypothesisToShape--END")
+ MESSAGE("AddHypothesisToShape--END");
return true;
}
//
SALOME::ExceptionStruct es;
es.type = SALOME::BAD_PARAM;
-#ifdef _DEBUG_
- texte += "\nInvalid AddBoundaryGroup";
-#endif
+
+ if (SALOME::VerbosityActivated())
+ texte += "\nInvalid AddBoundaryGroup";
+
INFOS(texte);
es.text = CORBA::string_dup(texte.c_str());
throw SALOME::SALOME_Exception(es);
#include "SMESH_TryCatch.hxx" // include after OCCT headers!
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
using namespace std;
using SMESH::TPythonDump;
using SMESH::TVar;
if ( prevNbMeshEnt > 0 /*newNbMeshEnt != prevNbMeshEnt*/ )
_gen_i->UpdateIcons( mesh );
}
- if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
+ MESSAGE( " AddHypothesis(): status = " << status );
// Update Python script
TPythonDump() << "status = " << mesh << ".AddHypothesis( "
SMESH::SMESH_Hypothesis_ptr anHyp,
std::string* anErrorText)
{
- if(MYDEBUG) MESSAGE("addHypothesis");
+ MESSAGE("addHypothesis");
if (CORBA::is_nil( aSubShape ) && HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference",SALOME::BAD_PARAM);
SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp)
{
- if(MYDEBUG) MESSAGE("removeHypothesis()");
+ MESSAGE("removeHypothesis()");
if (CORBA::is_nil( aSubShape ) && HasShapeToMesh())
THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
{
Unexpect aCatch(SALOME_SalomeException);
- if (MYDEBUG) MESSAGE("GetHypothesisList");
+ MESSAGE("GetHypothesisList");
if (_impl->HasShapeToMesh() && CORBA::is_nil(aSubShape))
THROW_SALOME_CORBA_EXCEPTION("bad Sub-shape reference", SALOME::BAD_PARAM);
SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes()
{
Unexpect aCatch(SALOME_SalomeException);
- if (MYDEBUG) MESSAGE("GetSubMeshes");
+ MESSAGE("GetSubMeshes");
SMESH::submesh_array_var aList = new SMESH::submesh_array();
SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
{
Unexpect aCatch(SALOME_SalomeException);
- if (MYDEBUG) MESSAGE("GetGroups");
+ MESSAGE("GetGroups");
SMESH::ListOfGroups_var aList = new SMESH::ListOfGroups();
SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theSubShapeObject )
{
- if(MYDEBUG) MESSAGE( "createSubMesh" );
+ MESSAGE( "createSubMesh" );
TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject);
::SMESH_subMesh * mySubMesh = _impl->GetSubMesh(myLocSubShape);
int subMeshId = 0;
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( subMesh );
- if(MYDEBUG) { MESSAGE( "Add submesh to map with id = "<< nextId); }
- else { (void)nextId; } // avoid "unused variable" warning
+ MESSAGE( "Add submesh to map with id = "<< nextId);
// to track changes of GEOM groups
if ( subMeshId > 0 )
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( aGroup );
- if(MYDEBUG) { MESSAGE( "Add group to map with id = "<< nextId); }
- else { nextId = ( nextId > 0 ); } // avoid "unused variable" warning in release mode
+ MESSAGE( "Add group to map with id = "<< nextId);
// to track changes of GEOM groups
if ( !theShape.IsNull() ) {
void SMESH_Mesh_i::removeGroup( const int theId )
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeGroup()" );
+ MESSAGE("SMESH_Mesh_i::removeGroup()");
if ( _mapGroups.find( theId ) != _mapGroups.end() ) {
SMESH::SMESH_GroupBase_var group = _mapGroups[theId];
_mapGroups.erase( theId );
void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl)
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh_i::SetImpl");
+ MESSAGE("SMESH_Mesh_i::SetImpl");
_impl = impl;
if ( _impl )
_impl->SetCallUp( new TCallUp_i(this));
::SMESH_Mesh & SMESH_Mesh_i::GetImpl()
{
- if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetImpl()");
+ MESSAGE("SMESH_Mesh_i::GetImpl()");
return *_impl;
}
_preMeshInfo->FullLoadFromFile();
CORBA::LongLong pointeur = CORBA::LongLong(_impl);
-
if ( MYDEBUG ) MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
+ MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
return pointeur;
}
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( groupVar );
- if(MYDEBUG) { MESSAGE( "Add group to map with id = "<< nextId); }
- else { (void)nextId; } // avoid "unused variable" warning in release mode
+ MESSAGE( "Add group to map with id = "<< nextId);
// publishing the groups in the study
GEOM::GEOM_Object_var shapeVar = _gen_i->ShapeToGeomObject( shape );
#include <vector>
#include <string>
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
using namespace std;
TCollection_AsciiString aMethod = aCmd->GetMethod();
TCollection_AsciiString aObject = aCmd->GetObject();
TCollection_AsciiString aResultValue = aCmd->GetResultValue();
- if(MYDEBUG) {
+ if(SALOME::VerbosityActivated()) {
cout<<"Command before : "<< aCmd->GetString()<<endl;
cout<<"Method : "<< aMethod<<endl;
cout<<"Object : "<< aObject<<endl;
}
if(it != _objectMap.end()) {
- if(MYDEBUG)
+ if(SALOME::VerbosityActivated())
cout << "Found object : " << (*it).first << endl;
SMESH_ObjectStates *aStates = (*it).second;
// Case for LocalLength hypothesis
if(aMethod == "SetLayerDistribution"){
LayerDistributionStates* aLDStates = (LayerDistributionStates*)(aStates);
aLDStates->AddDistribution(aCmd->GetArg(1));
- if(MYDEBUG)
+ if(SALOME::VerbosityActivated())
cout<<"Add Distribution :"<<aCmd->GetArg(1)<<endl;
}
}
}
}
else {
- if(MYDEBUG)
+ if(SALOME::VerbosityActivated())
cout << "Object not found" << endl;
}
- if(MYDEBUG) {
+ if(SALOME::VerbosityActivated()) {
cout<<"Command after: "<< aCmd->GetString()<<endl;
}
}
std::vector< std::string > allVars = aGen->GetAllParameters( anID.in() );
SALOMEDS::ListOfListOfStrings_var aSections = aStudy->ParseVariables(aParameters.in());
_entry2VarsMap[ TCollection_AsciiString( anID.in() )] = allVars;
- if(MYDEBUG) {
+ if(SALOME::VerbosityActivated()) {
cout<<"Entry : "<< anID<<endl;
cout<<"aParameters : "<<aParameters<<endl;
}
else if (!aMesh->_is_nil() ) {
anObjType = "Mesh";
}
- if(MYDEBUG)
+ if(SALOME::VerbosityActivated())
cout<<"The object Type : "<<anObjType<<endl;
SMESH_ObjectStates *aState = NULL;
if(anObjType == "LayerDistribution")
aVar.InsertAfter(aVar.Length(), SMESH::TVar::Quote() );
}
aVars.push_back(aVar);
- if(MYDEBUG) {
+ if(SALOME::VerbosityActivated()) {
cout<<"Variable: '"<<aVar<<"'"<<endl;
}
}
//================================================================================
void SMESH_NoteBook::AddCommand(const TCollection_AsciiString& theString)
{
- if(MYDEBUG)
+ if(SALOME::VerbosityActivated())
cout<<theString<<endl;
Handle(_pyCommand) aCommand = new _pyCommand( theString, -1);
_commands.push_back(aCommand);
// -- Most probably a bad study was saved when there were
// not fixed bugs in SMDS_MeshInfo
if ( elemSet.size() < nbElems ) {
-#ifdef _DEBUG_
- cout << "SMESH_Gen_i::Load(), warning: Node position data is invalid" << endl;
-#endif
+ if (SALOME::VerbosityActivated())
+ cout << "SMESH_Gen_i::Load(), warning: Node position data is invalid" << endl;
+
nbElems = elemSet.size();
}
// add elements to sub-meshes
#include <cstring>
-#ifdef _DEBUG_
-static int MYDEBUG = 0;
-#else
-static int MYDEBUG = 0;
-#endif
-
#include "SMESH_TryCatch.hxx"
namespace SMESH
if ( !objEntry.empty() )
aCollection += (TVar::ObjPrefix() + objEntry ).c_str();
aSMESHGen->AddToPythonScript(aCollection);
- if(MYDEBUG) MESSAGE(aString);
+ MESSAGE(aString);
// prevent misuse of already treated variables
aSMESHGen->UpdateParameters(CORBA::Object_var().in(),"");
}
void printException( const char* text )
{
-#ifdef _DEBUG_
- std::cout << "Exception in SMESH_Gen_i::DumpPython(): " << text << std::endl;
-#else
- (void)text; // unused in release mode
-#endif
+ if (SALOME::VerbosityActivated())
+ std::cout << "Exception in SMESH_Gen_i::DumpPython(): " << text << std::endl;
}
//=======================================================================
if ( iLoop > 20 )
{
-#ifdef _DEBUG_
- cout << "Infinite loop in AdaptiveAlgo::Compute()" << endl;
-#endif
+ if(SALOME::VerbosityActivated())
+ cout << "Infinite loop in AdaptiveAlgo::Compute()" << endl;
+
sizeDecreased = false;
break;
}
int _origNodeInd; // index of _hexNodes[0] node within the _grid
size_t _i,_j,_k;
bool _hasTooSmall;
-
-#ifdef _DEBUG_
int _cellID;
-#endif
public:
Hexahedron(Grid* grid);
tgtLink._link = _hexLinks + ( srcLink._link - other._hexLinks );
}
}
-#ifdef _DEBUG_
- _cellID = cellID;
-#else
- (void)cellID; // unused in release mode
-#endif
+
+ if (SALOME::VerbosityActivated())
+ _cellID = cellID;
}
//================================================================================
h->_eIntPoints.reserve(2);
h->_eIntPoints.push_back( ip );
added = true;
-#ifdef _DEBUG_
+
// check if ip is really inside the hex
- if ( h->isOutParam( ip->_uvw ))
+ if (SALOME::VerbosityActivated() && h->isOutParam( ip->_uvw ))
throw SALOME_Exception("ip outside a hex");
-#endif
}
}
return added;
helper.GetMeshDS()->RemoveFreeElement( v, /*sm=*/nullptr, /*fromGroups=*/false );
v = nullptr;
//_hasTooSmall = true;
-#ifdef _DEBUG_
- std::cout << "Remove INVALID polyhedron, _cellID = " << _cellID
- << " ijk = ( " << _i << " " << _j << " " << _k << " ) "
- << " solid " << volDef->_solidID << std::endl;
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ std::cout << "Remove INVALID polyhedron, _cellID = " << _cellID
+ << " ijk = ( " << _i << " " << _j << " " << _k << " ) "
+ << " solid " << volDef->_solidID << std::endl;
+ }
}
}
}
*/
bool Hexahedron::debugDumpLink( Hexahedron::_Link* link )
{
-#ifdef _DEBUG_
- gp_Pnt p1 = link->_nodes[0]->Point(), p2 = link->_nodes[1]->Point();
- cout << "BUG: not shared link. IKJ = ( "<< _i << " " << _j << " " << _k << " )" << endl
- << "n1 (" << p1.X() << ", "<< p1.Y() << ", "<< p1.Z() << " )" << endl
- << "n2 (" << p2.X() << ", "<< p2.Y() << ", "<< p2.Z() << " )" << endl;
-#else
- (void)link; // unused in release mode
-#endif
+ if (SALOME::VerbosityActivated())
+ {
+ gp_Pnt p1 = link->_nodes[0]->Point(), p2 = link->_nodes[1]->Point();
+ cout << "BUG: not shared link. IKJ = ( "<< _i << " " << _j << " " << _k << " )" << endl
+ << "n1 (" << p1.X() << ", "<< p1.Y() << ", "<< p1.Z() << " )" << endl
+ << "n2 (" << p2.X() << ", "<< p2.Y() << ", "<< p2.Z() << " )" << endl;
+ }
+
return false;
}
//================================================================================
if (mySides.size() != 4)
return false;
-#ifdef _DEBUG_
+if (SALOME::VerbosityActivated())
+{
mySides.GetSide( Q_BOTTOM )->SetID( Q_BOTTOM );
mySides.GetSide( Q_RIGHT )->SetID( Q_RIGHT );
mySides.GetSide( Q_TOP )->SetID( Q_TOP );
mySides.GetSide( Q_LEFT )->SetID( Q_LEFT );
-#endif
+}
return true;
}
void StdMeshers_FaceSide::dump(const char* msg) const
{
-#ifdef _DEBUG_
+ if (!SALOME::VerbosityActivated())
+ return;
+
if (msg) MESSAGE ( std::endl << msg );
MESSAGE_BEGIN ("NB EDGES: "<< myEdge.size() );
MESSAGE_ADD ( "nbPoints: "<<myNbPonits<<" vecSize: " << myPoints.size()<<" "<<myFalsePoints.size() );
MESSAGE_ADD ( "\tF: "<<myFirst[i]<< " L: "<< myLast[i] );
MESSAGE_END ( "\tnormPar: "<<myNormPar[i]<<endl );
}
-#else
- (void)msg; // unused in release mode
-#endif
}
//================================================================================
using namespace std;
-// Define error message and _MYDEBUG_ if needed
-#ifdef _DEBUG_
+// Define error message
#define BAD_MESH_ERR \
error(SMESH_Comment("Can't detect block-wise structure of the input 2D mesh.\n" \
__FILE__ ":" )<<__LINE__)
-//#define _MYDEBUG_
-#else
-#define BAD_MESH_ERR \
- error(SMESH_Comment("Can't detect block-wise structure of the input 2D mesh"))
-#endif
-
// Debug output
-#ifdef _MYDEBUG_
#define _DUMP_(msg) cout << msg << endl
-#else
-#define _DUMP_(msg)
-#endif
-
namespace
{
{
B_BOTTOM=0, B_RIGHT, B_TOP, B_LEFT, B_FRONT, B_BACK, NB_BLOCK_SIDES
};
-#ifdef _MYDEBUG_
+
const char* SBoxSides[] = //!< names of block sides -- needed for DEBUG only
{
"BOTTOM", "RIGHT", "TOP", "LEFT", "FRONT", "BACK", "UNDEFINED"
};
-#endif
+
enum EQuadEdge //!< edges of quadrangle side
{
Q_BOTTOM = 0, Q_RIGHT, Q_TOP, Q_LEFT, NB_QUAD_SIDES
void pointsToPython(const std::vector<gp_XYZ>& p)
{
-#ifdef _DEBUG_
- for ( size_t i = SMESH_Block::ID_V000; i < p.size(); ++i )
+ if (SALOME::VerbosityActivated())
{
- cout << "mesh.AddNode( " << p[i].X() << ", "<< p[i].Y() << ", "<< p[i].Z() << ") # " << i <<" " ;
- SMESH_Block::DumpShapeID( i, cout ) << endl;
+ for ( size_t i = SMESH_Block::ID_V000; i < p.size(); ++i )
+ {
+ cout << "mesh.AddNode( " << p[i].X() << ", "<< p[i].Y() << ", "<< p[i].Z() << ") # " << i <<" " ;
+ SMESH_Block::DumpShapeID( i, cout ) << endl;
+ }
}
-#else
- (void)p; // unused in release mode
-#endif
}
} // namespace
continue;
}
}
-#ifdef _DEBUG_
- TopTools_IndexedMapOfShape allShapes; // usage: allShapes.FindIndex( s )
- TopExp::MapShapes( shape, allShapes );
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ TopTools_IndexedMapOfShape allShapes; // usage: allShapes.FindIndex( s )
+ TopExp::MapShapes( shape, allShapes );
+ }
TopTools_IndexedDataMapOfShapeListOfShape facesOfEdge;
TopTools_ListIteratorOfListOfShape faceIt;
if ( iLoop > allFaces.Extent() * 10 )
{
isOK = false;
-#ifdef _DEBUG_
- cerr << "BUG: infinite loop in StdMeshers_Prism_3D::IsApplicable()" << endl;
-#endif
+
+ if(SALOME::VerbosityActivated())
+ {
+ cerr << "BUG: infinite loop in StdMeshers_Prism_3D::IsApplicable()" << endl;
+ }
}
} // while hasAdvanced
void StdMeshers_PrismAsBlock::faceGridToPythonDump(const SMESH_Block::TShapeID face,
const int nb)
{
-#ifdef _DEBUG_
+ if(!SALOME::VerbosityActivated())
+ return;
+
gp_XYZ pOnF[6] = { gp_XYZ(0,0,0), gp_XYZ(0,0,1),
gp_XYZ(0,0,0), gp_XYZ(0,1,0),
gp_XYZ(0,0,0), gp_XYZ(1,0,0) };
<< n << ", " << n+1 << ", "
<< n+nb+2 << ", " << n+nb+1 << "]) " << endl;
}
-#else
- (void)face; // unused in release mode
- (void)nb; // unused in release mode
-#endif
}
//================================================================================
void StdMeshers_PrismAsBlock::TSideFace::dumpNodes(int nbNodes) const
{
-#ifdef _DEBUG_
+ if (!SALOME::VerbosityActivated())
+ return;
+
cout << endl << "NODES OF FACE "; SMESH_Block::DumpShapeID( myID, cout ) << endl;
THorizontalEdgeAdaptor* hSize0 = (THorizontalEdgeAdaptor*) HorizCurve(0);
cout << "Horiz side 0: "; hSize0->dumpNodes(nbNodes); cout << endl;
TVerticalEdgeAdaptor* vSide1 = (TVerticalEdgeAdaptor*) VertiCurve(1);
cout << "Verti side 1: "; vSide1->dumpNodes(nbNodes); cout << endl;
delete hSize0; delete hSize1; delete vSide0; delete vSide1;
-#else
- (void)nbNodes; // unused in release mode
-#endif
}
//================================================================================
void StdMeshers_PrismAsBlock::TVerticalEdgeAdaptor::dumpNodes(int nbNodes) const
{
-#ifdef _DEBUG_
+ if (!SALOME::VerbosityActivated())
+ return;
+
for ( int i = 0; i < nbNodes && i < (int)myNodeColumn->size(); ++i )
cout << (*myNodeColumn)[i]->GetID() << " ";
if ( nbNodes < (int) myNodeColumn->size() )
cout << myNodeColumn->back()->GetID();
-#else
- (void)nbNodes; // unused in release mode
-#endif
}
//================================================================================
void StdMeshers_PrismAsBlock::THorizontalEdgeAdaptor::dumpNodes(int nbNodes) const
{
-#ifdef _DEBUG_
+ if (!SALOME::VerbosityActivated())
+ return;
+
// Not bedugged code. Last node is sometimes incorrect
const TSideFace* side = mySide;
double u = 0;
side->GetColumns( u , col, col2 );
if ( n != col->second[ i ] )
cout << col->second[ i ]->GetID();
-#else
- (void)nbNodes; // unused in release mode
-#endif
}
//================================================================================
bool storeShapeForDebug(const TopoDS_Shape& shape)
{
bool toShow;
-#ifdef _DEBUG_
- const char* type[] ={"COMPOUND","COMPSOLID","SOLID","SHELL","FACE","WIRE","EDGE","VERTEX"};
- BRepTools::Write( shape, SMESH_Comment("/tmp/") << type[shape.ShapeType()] << "_"
- << shape.TShape().operator->() << ".brep");
- toShow = !theMeshDS[0]; // no show
-#else
- toShow = theMeshDS[0]; // no show
-#endif
+
+ if (SALOME::VerbosityActivated())
+ {
+ const char* type[] ={"COMPOUND","COMPSOLID","SOLID","SHELL","FACE","WIRE","EDGE","VERTEX"};
+ BRepTools::Write( shape, SMESH_Comment("/tmp/") << type[shape.ShapeType()] << "_"
+ << shape.TShape().operator->() << ".brep");
+ toShow = !theMeshDS[0]; // no show
+ }
+ else
+ {
+ toShow = theMeshDS[0]; // no show
+ }
+
if ( toShow ) {
show_shape( shape, "avoid warning: show_shape() defined but not used");
show_list( "avoid warning: show_list() defined but not used", list< TopoDS_Edge >() );
// b) find association of a couple of vertices and recall self.
//
-#ifdef _DEBUG_
- theMeshDS[0] = theMesh1->GetMeshDS(); // debug
- theMeshDS[1] = theMesh2->GetMeshDS();
-#endif
+ if (SALOME::VerbosityActivated())
+ {
+ theMeshDS[0] = theMesh1->GetMeshDS(); // debug
+ theMeshDS[1] = theMesh2->GetMeshDS();
+ }
// =================================================================================
// 1) Is it the case of associating a group member -> another group? (PAL16202, 16203)
const double D = M.Determinant();
if ( D < 1e-3 * ( newSrcOrig - _srcOrig ).Modulus() )
{
-#ifdef _DEBUG_
- cerr << "TrsfFinder3D::Invert()"
+ if (SALOME::VerbosityActivated())
+ cerr << "TrsfFinder3D::Invert()"
<< "D " << M.Determinant() << " IsSingular " << M.IsSingular() << endl;
-#endif
+
return false;
}
gp_Mat Minv = M.Inverted();
TAssocTool::Morph morph( srcWires );
morph.Perform( helper, tgtWires, helper.GetSurface( tgtFace ),
_src2tgtNodes, /*moveAll=*/true );
-#ifdef _DEBUG_
- cout << "StdMeshers_Projection_2D: Projection mesh IsDistorted2D() ==> do morph" << endl;
-#endif
+ if(SALOME::VerbosityActivated())
+ cout << "StdMeshers_Projection_2D: Projection mesh IsDistorted2D() ==> do morph" << endl;
if ( !fixDistortedFaces( helper, tgtWires )) // smooth and check
return error("Invalid mesh generated");
theVariants.insert( *this );
-#ifndef _DEBUG_
- if ( theVariants.size() > 1 ) // erase a worse variant
+ if (SALOME::VerbosityActivated() && theVariants.size() > 1 ) // erase a worse variant
theVariants.erase( ++theVariants.begin() );
-#endif
};
// first criterion - equality of nbSeg of opposite sides
void _ViscousBuilder::makeGroupOfLE()
{
-#ifdef _DEBUG_
+ if (!SALOME::VerbosityActivated())
+ return;
+
for ( size_t i = 0 ; i < _sdVec.size(); ++i )
{
if ( _sdVec[i]._n2eMap.empty() ) continue;
<< "'%s-%s' % (faceId1+1, faceId2))");
dumpFunctionEnd();
}
-#endif
}
//================================================================================
}
}
-
-
-#ifdef _DEBUG_
- // dumpMove() for debug
- size_t i = 0;
- for ( ; i < eos._edges.size(); ++i )
- if ( eos._edges[i]->Is( _LayerEdge::MARKED ))
- break;
- if ( i < eos._edges.size() )
+ if (SALOME::VerbosityActivated())
{
- dumpFunction(SMESH_Comment("putOnOffsetSurface_") << eos.ShapeTypeLetter() << eos._shapeID
- << "_InfStep" << infStep << "_" << Abs( smooStep ));
+ // dumpMove() for debug
+ size_t i = 0;
for ( ; i < eos._edges.size(); ++i )
+ if ( eos._edges[i]->Is( _LayerEdge::MARKED ))
+ break;
+ if ( i < eos._edges.size() )
{
- if ( eos._edges[i]->Is( _LayerEdge::MARKED )) {
- dumpMove( eos._edges[i]->_nodes.back() );
+ dumpFunction(SMESH_Comment("putOnOffsetSurface_") << eos.ShapeTypeLetter() << eos._shapeID
+ << "_InfStep" << infStep << "_" << Abs( smooStep ));
+ for ( ; i < eos._edges.size(); ++i )
+ {
+ if ( eos._edges[i]->Is( _LayerEdge::MARKED )) {
+ dumpMove( eos._edges[i]->_nodes.back() );
+ }
}
+ dumpFunctionEnd();
}
- dumpFunctionEnd();
}
-#endif
_ConvexFace* cnvFace;
if ( moveAll != _LayerEdge::UPD_NORMAL_CONV &&
bool SetNewLength( const double length );
-#ifdef _DEBUG_
- int _ID;
-#endif
+ int _ID; // debug
};
//--------------------------------------------------------------------------------
/*!
_error->myAlgo = smError->myAlgo;
smError = _error;
}
-#ifdef _DEBUG_
- cout << "_ViscousBuilder2D::error " << text << endl;
-#endif
+
+ if (SALOME::VerbosityActivated())
+ cout << "_ViscousBuilder2D::error " << text << endl;
+
return false;
}
lEdge._ray.SetDirection( lEdge._normal2D );
lEdge._isBlocked = false;
lEdge._length2D = 0;
-#ifdef _DEBUG_
- lEdge._ID = _nbLE++;
-#endif
+
+ if (SALOME::VerbosityActivated())
+ lEdge._ID = _nbLE++;
}
//================================================================================
