终于把之前的并行出错的问题解决了，还是要感谢@wwzhao 和@cfd-china 的帮助。
简单一点，我之前的代码，在主函数中是这样的：

int main()
{
         .......
         if( // condition )           
         {
                .......
                U.correctBoundaryConditions();
                T.correctBoundaryConditions();
                p.correctBoundaryConditions();
                .......
         }
}

这里加if的作用是因为我的代码，在并行的时候，并不是每个语句对proccessor都通用，比如说一些量的定义和操作等，因此加了个if判断一下。

也就是说，这个地方对于有的proccessor执行了更新边界的操作，而有的processor并没有更新，这样会导致processor之间的数据交换发生问题（我个人的理解），因此就会报错。为了使得每个processor的差别仅仅是一些量定义和运算的差异，而在其他地方都同等对待，比如边界场的更新（因为proccessor之间也是通过processor边界进行数据交流的），因此我将上述代码改成如下形式：

int main()
{
         .......
         if( // condition )           
         {
                .......
                
                .......
         }
        U.correctBoundaryConditions();
        T.correctBoundaryConditions();
        p.correctBoundaryConditions();
}

这样，对于每个processor来说，都同时更新了边界，数据交换就没问题了。

我的case比较特殊，INLET入口边界条件是自定义的，有一些量的运算和赋值，不能破坏INLET边界，所以我用的是simple分块方法，也就是说只有processor0才会有INLET的faces，因此我的求解器代码，不能针对所有的processor，要加一些判断语句来区别processor0，另外，由于每个processor都调用了boundaryConditions()，因此自定义的INLET边界条件代码根据不同的processor也要加判断，执行不同的代码。所以在并行的时候，既要考虑到每个processor的运行代码，还要考虑到他们之间的数据交换是否存在问题。

以上是我个人的理解，大家有什么不同的看法可以讨论哈。

现在我的case还在算着，不知道结果怎么样，还是祈祷吧~~

你这个是为了避免分母除0是吧，VSMALL=1.0e-37，是一个scalar的量，从代码上看rho1()，rho2()应该是两个volScalarField类型，有一种办法就是构造一个同样的volScalarField场，比如

volScalarField zeroField
(
     IOobject
     (
          "ZERO",
          runTime.timeName(),
          mesh
     ),
     mesh,
     dimesionedScalar("vsmall", dimensionSet(1,-3,0,0,0,0,0), VSMALL)
)

名字嘛，如果不lookup的话，随便起吧。

@wwzhao 我没有用到operator new操作符。

我大部分代码还是of自己的，额外加的地方就是定义了两个类，两个个函数和一些全局变量，如下图：

单核运行是可以的话，代码应该问题不大吧？

前两个是定义的两个类，第三个是一些变量（相当于全局变量），最后两个是定义的函数。为了方便，我都写成了#include 。

上面的Invalid read of size 8的错误我在OF自己的求解器并行算了一下，还是有这个，但是可以运行。我想应该不是我代码本身的问题。虽然不知道是什么原因，但这个错误应该不至于我的求解器算不下去。

我想问题就出现在了我之前提到的另外的那个错误，类似于4 bytes in 1 blocks are still reachable in loss record 1 of 4267。

@wwzhao 不是，我程序中有一句写的不对

const vectorField& Cf = patch.Cf()/delta1VD;

vectorField meanVelocity(Cf.size());

我改成：

vectorField Cf = patch.Cf()/delta1VD;
vectorField meanVelocity(Cf.size());

或者

tmp<vectorField> tCf =  patch.Cf()/delta1VD;
const vectorField& Cf = tCf();
vectorField meanVelocity(Cf.size());

就可以了

ICEM中对网格进行了局部加密，局部加密了以后，不同block的同一条edge上节点不一样，我在mapFields时会不会出问题？

@李东岳 谢谢啦

我之前算了一个算例，网格比较大，最近新创建了一个模型（几何稍微不同），想把之间算好的场映射到新的模型中进行并行计算，如何并行处理映射呢？我如果不进行并行映射，由于网格量太大导致mapFields时出现内存不足的问题。mapFields里有-parallel选项，但不太清楚怎么使用:crying:

在后处理求解马赫数的时候，用Mach执行，但出现如下的错误：

Time = 0.00056
Selecting thermodynamics package 
{
    type            hePsiThermo;
    mixture         pureMixture;
    transport       sutherland;
    thermo          eConst;
    equationOfState perfectGas;
    specie          specie;
    energy          sensibleInternalEnergy;
}



--> FOAM FATAL ERROR: 
Not Implemented
    Trying to construct an genericFvPatchField on patch boundaryInner of field e

    From function genericFvPatchField<Type>::genericFvPatchField(const fvPatch& p, const DimensionedField<Type, volMesh>& iF)
    in file genericFvPatchField/genericFvPatchField.C at line 44.

FOAM aborting

#0  Foam::error::printStack(Foam::Ostream&) in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/lib/libOpenFOAM.so"
#1  Foam::error::abort() in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/lib/libOpenFOAM.so"
#2  Foam::fvPatchField<double>::addpatchConstructorToTable<Foam::genericFvPatchField<double> >::New(Foam::fvPatch const&, Foam::DimensionedField<double, Foam::volMesh> const&) in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/lib/libgenericPatchFields.so"
#3  Foam::fvPatchField<double>::New(Foam::word const&, Foam::word const&, Foam::fvPatch const&, Foam::DimensionedField<double, Foam::volMesh> const&) in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/bin/Mach"
#4  Foam::GeometricField<double, Foam::fvPatchField, Foam::volMesh>::GeometricBoundaryField::GeometricBoundaryField(Foam::fvBoundaryMesh const&, Foam::DimensionedField<double, Foam::volMesh> const&, Foam::List<Foam::word> const&, Foam::List<Foam::word> const&) in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/lib/libfluidThermophysicalModels.so"
#5  Foam::heThermo<Foam::psiThermo, Foam::pureMixture<Foam::sutherlandTransport<Foam::species::thermo<Foam::eConstThermo<Foam::perfectGas<Foam::specie> >, Foam::sensibleInternalEnergy> > > >::heThermo(Foam::fvMesh const&, Foam::word const&) in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/lib/libfluidThermophysicalModels.so"
#6  Foam::fluidThermo::addfvMeshConstructorToTable<Foam::hePsiThermo<Foam::psiThermo, Foam::pureMixture<Foam::sutherlandTransport<Foam::species::thermo<Foam::eConstThermo<Foam::perfectGas<Foam::specie> >, Foam::sensibleInternalEnergy> > > > >::New(Foam::fvMesh const&, Foam::word const&) in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/lib/libfluidThermophysicalModels.so"
#7  Foam::fluidThermo::New(Foam::fvMesh const&, Foam::word const&) in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/lib/libfluidThermophysicalModels.so"
#8  ? in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/bin/Mach"
#9  ? in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/bin/Mach"
#10  ? in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/bin/Mach"
#11  __libc_start_main in "/lib64/libc.so.6"
#12  ? in "/WORK/app/OpenFOAM/OpenFOAM-2.4.0/platforms/linux64IccDPOpt/bin/Mach"
Aborted (core dumped)

这种情况我之前是没有遇到过的，于是检查了一下Mach.C的源码：

#include "calc.H"
#include "fluidThermo.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
{
    bool writeResults = !args.optionFound("noWrite");

    IOobject Uheader
    (
        "U",
        runTime.timeName(),
        mesh,
        IOobject::MUST_READ
    );

    IOobject Theader
    (
        "T",
        runTime.timeName(),
        mesh,
        IOobject::MUST_READ
    );

    // Check U and T exists
    if (Uheader.headerOk() && Theader.headerOk())
    {
        autoPtr<volScalarField> MachPtr;

        volVectorField U(Uheader, mesh);
        if
        (
            IOobject
            (
                "thermophysicalProperties",
                runTime.constant(),
                mesh
            ).headerOk()
        )
        {
            // thermophysical Mach
            autoPtr<fluidThermo> thermo
            (
                fluidThermo::New(mesh)
            );

            volScalarField Cp(thermo->Cp());
            volScalarField Cv(thermo->Cv());

            MachPtr.set
            (
                new volScalarField
                (
                    IOobject
                    (
                        "Ma",
                        runTime.timeName(),
                        mesh
                    ),
                    mag(U)/(sqrt((Cp/Cv)*(Cp - Cv)*thermo->T()))
                )
            );
        }
        else
        {
            // thermodynamic Mach
               IOdictionary thermoProps
            (
                IOobject
                (
                    "thermodynamicProperties",
                    runTime.constant(),
                    mesh,
                    IOobject::MUST_READ_IF_MODIFIED,
                    IOobject::NO_WRITE
                )
            );

            dimensionedScalar R(thermoProps.lookup("R"));
            dimensionedScalar Cv(thermoProps.lookup("Cv"));

            volScalarField T(Theader, mesh);

            MachPtr.set
            (
                new volScalarField
                (
                    IOobject
                    (
                        "Ma",
                        runTime.timeName(),
                        mesh
                    ),
                    mag(U)/(sqrt(((Cv + R)/Cv)*R*T))
                )
            );
        }

        Info<< "Mach max : " << max(MachPtr()).value() << endl;
        if (writeResults)
        {
            MachPtr().write();
        }
    }
    else
    {
        Info<< "    Missing U or T" << endl;
    }

    Info<< "\nEnd\n" << endl;
}

代码中只要有U,T 和热力学模型就好了，不知道为什么错误提示要构造e这个场？谢谢各位！

delta可以选择cubeRootVol, vanDriest等，有没有谁比较过采用不同的delta，会对结果产生什么影响吗？

最近计算一个可压流算例，用的是rhoCentralFoam，发现interpolationSchemes中的reconstruct(rho)等用tutorials默认的VanLeer格式，得到的结果过耗散，而采用Gamma得到比较清晰的云图。难道TVD格式与NVD格式相比有比较大的数值耗散吗？

另外我看了一下Gamma.H代码，limiter返回的是phict/k，这个我猜测是Jasak文章中的blending factor吧？OF中的Gamma格式和Jasak这篇文章中说的应该是一样的吧？但我不太清楚最后是如何计算面心的值，没有找到相关的代码，请各位大神指点一下。

reference
Jasak H, Weller H G, Gosman A D. High resolution NVD differencing scheme for arbitrarily unstructured meshes[J]. International Journal for Numerical Methods in Fluids, 1999, 31(2):431–449.

@wwzhao 好的，这个是我速度入口的边界条件

boundaryField
{
    inlet
    {
        type        syntheticVelocity;
        Ma          2.3;
        Tinf        104;
        Prt         0.9;
        nmodes      200;
        dxmin       0.01e-03;
        Uinf        552;
        pInf        3998.63;
        pathName    "/home/Ubuntu/WORKPLACE4/syntheticCase-test/data";
        value       uniform (552 0 0);
    }

   other boundaries ......
}

由于刚开始计算的时候不知道Ubar，ReynoldStress和deltaInlet，在边条构造时需要通过那个calculateProfiles函数计算。

那个pathName 是我的文件所在的地方

其中的data文件中的数据是一列一列排布的，
0_1479171527178_data

可能我描述的问题不够准确，下面附上我的部分代码：
在.H文件中，定义了一些私有变量与私有变量的接口：

// private perameters
  //- freestream Ma
        scalar Ma_;
        
        //- freestream T
        scalar Tinf_;
        
        scalar gamma_;
        
        scalar Prt_;
        
        //- munber of modes
        scalar nmodes_;
        
        //- smallest wavenumber
        scalar dxmin_;

        //- ratio of ke and kmin (in wavenumber)
        scalar wew1fct_;
        
        //-
        scalar amp_;
        
        //- kinetic viscosity of the smallest eddy
        scalar visc_;
        
        //- delta Inlet
        scalar deltaInlet_;
        
        //- freestream Velocity
        scalar Uinf_;
        
        //- freestream pressure
        scalar pInf_;
        
        //- read file
        IFstream IF_;
        
        //- rows of file data
        label ny_;
        
        //- MeanField
        vectorField Ubar_;
        
        //- primeField
        vectorField UPrime_;
        
        //- ReynoldStress tensor
        symmTensorField  ReynoldStress_;
        
        label curTimeIndex_;
        
        // member function
        void calculateProfiles(IFstream&, vectorField&, symmTensorField&, scalar&);

        
// Access
	    
	    scalar nmodes() const
	    {
	    	return nmodes_;
	    }
	    
	    scalar deltaInlet() const
	    {
	    	return deltaInlet_;
	    }
	    
	    scalar& deltaInlet()
	    {
	    	return deltaInlet_;
	    }
	    
	    scalar amp() const
	    {
	    	return amp_;
	    }
	    
	    scalar dxmin() const
	    {
	    	return dxmin_;
	    }
	    
	    scalar visc() const
	    {
	    	return visc_;
	    }
	    
	    scalar wew1fct() const
	    {
	    	return wew1fct_;
	    }
	    
	    scalar Ma() const
	    {
	    	return Ma_;
	    }
	    
	    scalar Tinf() const
	    {
	    	return Tinf_;
	    }
	    
	    scalar gamma() const
	    {
	    	return gamma_;
	    }
	    
	    scalar Prt() const
	    {
	    	return Prt_;
	    }
	    
	    scalar Uinf() const
	    {
	    	return Uinf_;
	    }
	    
	    scalar pInf() const
	    {
	    	return pInf_;
	    }
	    
	    IFstream IF() const
	    {
	    	return IF_;
	    }
	    
	    IFstream& IF()
	    {
	    	return IF_;
	    }
	    
	    vectorField& Ubar()
	    {
	    	return Ubar_;
	    }
	    
	    vectorField Ubar() const
	    {
	    	return Ubar_;
	    }
	    
	    symmTensorField& ReynoldStress()
	    {
	    	return ReynoldStress_;
	    }
	    
	    symmTensorField ReynoldStress() const
	    {
	    	return ReynoldStress_;
	    }
	    
	    label ny()
	    {
	    	return ny_;
	    }

然后在.C中，我的构造函数：

// constrctor
Foam::syntheticVelocityFixedValueFvPatchField::syntheticVelocityFixedValueFvPatchField
(
    const fvPatch& p,
    const DimensionedField<vector, volMesh>& iF,
    const dictionary& dict
)
:
    fixedValueFvPatchVectorField(p, iF),
    Ma_(readScalar(dict.lookup("Ma"))),
    Tinf_(readScalar(dict.lookup("Tinf"))),
    gamma_(dict.lookupOrDefault("gamma", 1.4)),
    Prt_(dict.lookupOrDefault("Prt", 0.9)),
    nmodes_(readScalar(dict.lookup("nmodes"))),
    dxmin_(readScalar(dict.lookup("dxmin"))),
    wew1fct_(dict.lookupOrDefault("wew1fct", 2.0)),
    amp_(dict.lookupOrDefault("amp", 1.452762113)),
    visc_(dict.lookupOrDefault("visc", 15.2e-6)),
    Uinf_(readScalar(dict.lookup("Uinf"))),
    pInf_(readScalar(dict.lookup("pInf"))),
    IF_(dict.lookup("pathName")),	// stored meanStreamVelocity and ReynoldStress profile data
    ny_(dict.lookupOrDefault("ny", 535)),
    curTimeIndex_(-1)
{
    if (dict.found("Ubar") && dict.found("ReynoldStress") && dict.found("deltaInlet"))
    {
    	deltaInlet_= scalar(readScalar(dict.lookup("deltaInlet")));
    	Ubar_ = vectorField("Ubar", dict, p.size());
    	ReynoldStress_ = symmTensorField("ReynoldStress", dict, p.size());
    }
    else
    {
    	calculateProfiles(IF(), Ubar(), ReynoldStress(), deltaInlet());
    }
    
    if (dict.found("UPrime"))
    {
    	UPrime_ = vectorField("UPrime", dict, p.size());
    }
    else
    {
    	UPrime_ = vectorField(p.size(), vector::zero);
    }
    
    if (dict.found("value"))
    {
        fvPatchField<vector>::operator=
        (
            vectorField("value", dict, p.size())
        );
    }
    else
    {
        fvPatchField<vector>::operator=(Ubar());
    }
}        

这里调用的成员函数calculateProperties如下：

// member function
void Foam::syntheticVelocityFixedValueFvPatchField::calculateProfiles
(
    IFstream& IF,
    vectorField& Ubar,
    symmTensorField& ReynoldStress,
    scalar& deltaInlet
)
{
    if (!IF)
    {
    	FatalErrorIn("void Foam::syntheticVelocityFixedValueFvPatchField::calculateMeanVelocity")
    	 << "can not find " << IF.name() << exit(FatalError);
    }
    else
    {
    	scalarField UvdPlus(ny()), vPlus(ny()), wPlus(ny()), Ux(ny()), Uy(ny()), Uz(ny());
    	symmTensorField stressPlus(ny(), symmTensor::zero);
    	scalarField yPlus(ny()), y(ny());
    	scalar yInf, ySup;
    	scalar R(287.0), max_UvdPlus(26.457427), As(1.512e-06), Ts(120.0);
    	scalar r=pow(Prt(), 1.0/3.0);
    	//- calculate nuwInlet and Utao
    	scalar Taw = Tinf()*(1.0+(gamma()-1.0)/2.0*r*sqr(Ma()));
    	scalar Tw = (Taw - Tinf())/r + Tinf();
    	scalar rhow = pInf()/(R*Tw);
    	scalar muw = As*sqrt(Tw)/(1.0+Ts/Tw);
    	scalar nuwInlet = muw/rhow;
    	scalar A = sqrt((gamma()-1.0)/2.0*Prt()*sqr(Ma())*Tinf()/Tw);
    	scalar B = (1.0+sqrt(Prt())*(gamma()-1.0)/2.0*sqr(Ma()))*Tinf()/Tw - 1.0;   	
    	scalar Utao = Uinf()/A*(
    	                           asin((2.0*sqr(A)-B)/sqrt(sqr(B)+4.0*sqr(A)))
    	                         + asin(B/sqrt(sqr(B)+4.0*sqr(A)))
    	                       )/max_UvdPlus;	// max(Uvd+) = 25.6803733;
    	
    	const scalarField T = this->patch().lookupPatchField<volScalarField, scalar>("T");
    	//- flag to decide whether to calculate deltaInlet
    	bool delta=true;
    	forAll(UvdPlus, patchI)
    	{
    	    IF >> yPlus[patchI] >> UvdPlus[patchI] >> vPlus[patchI] >> wPlus[patchI]
    	       >> stressPlus[patchI].xx() >> stressPlus[patchI].yy() >> stressPlus[patchI].zz() >> stressPlus[patchI].xy();
    	    // calculate dimensional y
    	    y[patchI] = yPlus[patchI]*nuwInlet/Utao;
    	    // calculate dimensional Ux   	 
    	    scalar tmp = A*(UvdPlus[patchI]*Utao)/Uinf() - asin(B/sqrt(sqr(B)+4.0*sqr(A)));
    	    Ux[patchI] = (sin(tmp)*sqrt(sqr(B)+4.0*sqr(A)) + B)/(2.0*sqr(A))*Uinf(); 
    	    Uy[patchI] = vPlus[patchI]*Utao;
    	    Uz[patchI] = wPlus[patchI]*Utao; 
    	    
    	    if (Ux[patchI] > 0.99*Uinf() && delta)
    	    {
    	    	deltaInlet = y[patchI];
    	    	delta = false;	// deltaInlet calculated only once;
    	    } 	    
    	}
    	
    	vectorField Cf = this->patch().Cf();
    	Ubar = vectorField(Cf.size());
    	symmTensorField Reynold(Cf.size(), symmTensor::zero);
    	ReynoldStress = symmTensorField(Cf.size(), symmTensor::zero);
    	// interpolate at the cell
    	forAll(Cf, faceI)
    	{
    	    for(label patchI=0; patchI < y.size()-1; patchI++)
    	    {
    	    	yInf = Cf[faceI][1]-y[patchI];
    	    	ySup = Cf[faceI][1]-y[patchI+1];
    	    	if(yInf*ySup <= 0)
    	    	{
    	    	    Ubar[faceI][0] = yInf/(yInf-ySup)*Ux[patchI+1] - ySup/(yInf-ySup)*Ux[patchI];
    	    	    Ubar[faceI][1] = yInf/(yInf-ySup)*Uy[patchI+1] - ySup/(yInf-ySup)*Uy[patchI];
    	    	    Ubar[faceI][2] = yInf/(yInf-ySup)*Uz[patchI+1] - ySup/(yInf-ySup)*Uz[patchI];
    	    	    Reynold[faceI] = yInf/(yInf-ySup)*stressPlus[patchI+1] - ySup/(yInf-ySup)*stressPlus[patchI];
    	    	    // calculate dimensional Reynold stress
    	    	    scalar ksi = sqrt(Tw/T[faceI]);
    	    	    ReynoldStress[faceI].xx() = sqr(Reynold[faceI].xx()/ksi)*Utao;
    	    	    ReynoldStress[faceI].xy() = -sqr(Reynold[faceI].xy()/ksi)*Utao;
    	    	    ReynoldStress[faceI].yy() = sqr(Reynold[faceI].yy()/ksi)*Utao;
    	    	    ReynoldStress[faceI].zz() = sqr(Reynold[faceI].zz()/ksi)*Utao;
    	    	    
    	    	    break;
    	    	}
    	    	else	// Cf.component(1) is higher than y.last()
    	    	{
    	    	    Ubar[faceI][0] = Ux.last();
    	    	    Ubar[faceI][1] = Uy.last();
    	    	    Ubar[faceI][2] = Uz.last();
    	    	    scalar ksi = sqrt(Tw/T[faceI]);
    	    	    ReynoldStress[faceI].xx() = sqr(stressPlus.last().xx()/ksi)*Utao;
    	    	    ReynoldStress[faceI].xy() = -sqr(stressPlus.last().xy()/ksi)*Utao;
    	    	    ReynoldStress[faceI].yy() = sqr(stressPlus.last().yy()/ksi)*Utao;
    	    	    ReynoldStress[faceI].zz() = sqr(stressPlus.last().zz()/ksi)*Utao;	    
    	    	}
    	    }
    	}
    	
    	scalar ymin = min(Cf.component(1));
    	scalar Uxmin = min(Ubar.component(0));
    	scalar dUxdy = Uxmin/ymin;
    	scalar dUdy = sqr(Utao)/nuwInlet;
    	Info << "dUxdy (from case simulation)	=" << dUxdy << nl
    	     << "dUdy (from theory calculation)	=" << dUdy << nl
    	     << "Utao				=" << Utao << nl
    	     << "nuwInlet			=" << nuwInlet << nl
    	     << "deltaInlet			=" << deltaInlet << endl;
    }
}

我在单核下测试时时可以计算的，但是想并行计算的时候，decomposePar过不去，终端输出信息如下：

/*---------------------------------------------------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  2.4.0                                 |
|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
Build  : 2.4.0-dcea1e13ff76
Exec   : decomposePar
Date   : Nov 13 2016
Time   : 10:59:43
Host   : "zwk"
PID    : 12485
Case   : /home/Ubuntu/WORKPLACE4/SyntheticCase-test
nProcs : 1
sigFpe : Enabling floating point exception trapping (FOAM_SIGFPE).
fileModificationChecking : Monitoring run-time modified files using timeStampMaster
allowSystemOperations : Allowing user-supplied system call operations

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Create time



Decomposing mesh region0

Create mesh

Calculating distribution of cells
Selecting decompositionMethod simple

Finished decomposition in 0.04 s

Calculating original mesh data

Distributing cells to processors

Distributing faces to processors

Distributing points to processors

Constructing processor meshes

Processor 0
    Number of cells = 23686
    Number of faces shared with processor 1 = 1997
    Number of faces shared with processor 1 = 58
    Number of processor patches = 2
    Number of processor faces = 2055
    Number of boundary faces = 4243

Processor 1
    Number of cells = 23686
    Number of faces shared with processor 0 = 1997
    Number of faces shared with processor 0 = 58
    Number of faces shared with processor 2 = 1978
    Number of faces shared with processor 2 = 52
    Number of processor patches = 4
    Number of processor faces = 4085
    Number of boundary faces = 2189

Processor 2
    Number of cells = 23686
    Number of faces shared with processor 1 = 1978
    Number of faces shared with processor 1 = 52
    Number of faces shared with processor 3 = 1954
    Number of faces shared with processor 3 = 11
    Number of processor patches = 4
    Number of processor faces = 3995
    Number of boundary faces = 2329

Processor 3
    Number of cells = 23686
    Number of faces shared with processor 2 = 1954
    Number of faces shared with processor 2 = 11
    Number of faces shared with processor 4 = 1992
    Number of faces shared with processor 4 = 57
    Number of processor patches = 4
    Number of processor faces = 4014
    Number of boundary faces = 2276

Processor 4
    Number of cells = 23686
    Number of faces shared with processor 3 = 1992
    Number of faces shared with processor 3 = 57
    Number of faces shared with processor 5 = 1964
    Number of faces shared with processor 5 = 43
    Number of processor patches = 4
    Number of processor faces = 4056
    Number of boundary faces = 2208

Processor 5
    Number of cells = 23686
    Number of faces shared with processor 4 = 1964
    Number of faces shared with processor 4 = 43
    Number of faces shared with processor 6 = 1984
    Number of faces shared with processor 6 = 41
    Number of processor patches = 4
    Number of processor faces = 4032
    Number of boundary faces = 2330

Processor 6
    Number of cells = 23685
    Number of faces shared with processor 5 = 1984
    Number of faces shared with processor 5 = 41
    Number of faces shared with processor 7 = 1986
    Number of faces shared with processor 7 = 55
    Number of processor patches = 4
    Number of processor faces = 4066
    Number of boundary faces = 2218

Processor 7
    Number of cells = 23685
    Number of faces shared with processor 6 = 1986
    Number of faces shared with processor 6 = 55
    Number of processor patches = 2
    Number of processor faces = 2041
    Number of boundary faces = 4211

Number of processor faces = 14172
Max number of cells = 23686 (0.00105549% above average 23685.8)
Max number of processor patches = 4 (14.2857% above average 3.5)
Max number of faces between processors = 4085 (15.2978% above average 3543)

Time = 0
dUxdy (from case simulation)	=2.46405e+06
dUdy (from theory calculation)	=2.46471e+06
Utao				=23.1659
nuwInlet			=0.000217736
deltaInlet			=0.0144036

Processor 0: field transfer
terminate called after throwing an instance of 'std::logic_error'
  what():  basic_string::_S_construct null not valid

还麻烦各位可以给个意见，这个问题就是这个边条造成的，但不知道如何解决，谢谢各位了

不知道有没有哪位遇到过这样的情况，我在decomposePar的时候，出现这样的错误提示：

Processor 0: field transfer 
terminate called after throwing an instance of 'std::logic_error'
_what(): basic_string::_S_consturct null not valid

入口边界条件是我自己定义的，功能是读取一个文件数据，进行运算之后赋值给这个边界条件的私有变量。我用的是simple分块，不破坏这个入口。哪里出错了呢可以给点建议吗？

PS：单核验证可以计算

最近在用LES计算湍流入口，为了得到一个入口的平均速度场，我想用DNS的数据，也就是用到标准的壁面律曲线（y+ ~ U+），由于我用的求解器是求解有量纲的参数，因此需要对标准的壁面律曲线进行有量纲处理。根据我来流的参数，比如自由来流速度Uinf，温度Tinf，采用绝热壁温，是不是就可以得到有量纲的速度分布了？但我看到有人要给定入口的壁面摩擦速度Utao，边界层厚度等，这些都是没有必要的吧？谢谢！