GCC Code Coverage Report

double spaceUnit; // This number multiplies all the coordinates of the mesh. Example: if the mesh is in millimeters, spaceUnit = 0.1 convert it in centimeters

201

std::string model;

202

int testCase;

203

double u_max_inlet;

204

double max_flow_scaling;

double T_sis;

double T;

double symmetry;

std::vector<int> dimension;

209

210

// ROM

211

std::string ROMmethod;

212

bool solveEigenProblem;

213

bool optimizePotential;

214

double chiSchrodinger;

215

bool useROM;

216

felInt dimRomBasis;

217

felInt dimCollocationPts;

218

felInt numApproxMode;

219

felInt nCutOff;

220

std::string collocationPtsFile;

bool useImprovedRec;

felInt dimOrthComp;

int orderALP;

bool readBasisFromFile;

225

bool writeBasisEvolution;

226

bool hasSource;

227

int numberOfSource;

228

felInt numberOfSnapshot;

229

felInt samplingFrequency;

230

231

// POD

232

bool verbose_ensight;

int nbTestCase;

int snap_centered;

int L2Mass;

std::string output_dir;

237

std::string output_file;

238

std::string case_dir;

239

std::string case_file_name;

240

std::string snap_interval;

241

std::string variable_name;

242

std::string podFolder;

243

double timeStepSnap;

244

245

// Optimal reconstruction

246

double targetHR;

247

double timeWindowSize;

248

std::string image_modality;

249

double sistolicTime;

250

std::string patients_data_dir;

double HRwindowSize;

int nbMeasures;

int nbModes;

std::string targetTime;

255

bool useField2Measures;

256

bool doSnapshotsSVD;

257

bool calculateRieszRepresenters;

258

std::string measuresFile;

259

std::string targetSim;

260

std::string rrFolder;

261

std::string fieldFolder;

262

std::string hashTableMesh;

263

std::string modelReductionTechnique;

264

265

// Pressure estimation

266

int inletBoundaryLabel;

267

int wallBoundaryLabel;

268

std::vector<int> outletBoundaryLabels;

269

std::vector<std::string> testFunctionsPath;

270

std::vector<std::string> uStarPath;

271

272

// PostProcCFD

273

std::string caseDirCFD;

274

std::string caseFileNameCFD;

// Fluid

int orderBdfNS;

int orderBdfFS;

bool quasistatic;

double density;

double viscosity;

double NS_alpha; // like a capacitance in Rp,C,Rd lumpedModelBC model

283

double NS_beta; // like inverse of distal resistance in Rp,C,Rd lumpedModelBC model

284

double NS_gamma; // like proximal resistance in Rp,C,Rd lumpedModelBC model

285

int NSmodifFlag; // flag: 0 = no modified NS model

286

int NS_modifLabel; // currentLabel where we apply modified NS terms

287

int inletLabel; // label of an inlet of interest

288

int outletLabel; // label of an outlet of interest

289

double referenceValue1; // any reference value (general purpose)

290

double referenceValue2; // any reference value (general purpose)

291

double referenceValue3; // any reference value (general purpose)

292

double referenceValue4; // any reference value (general purpose)

293

int characteristicMethod; // to switch from semi-implicit resolution to method of characteristics

294

int addedBoundaryFlag; // flag: 0 = no stabilization

295

std::vector<int> stabilizationLabel; // label where we use stabilization

296

double stabilizationCoef; // coef for tune stabilization

297

int explicitAdvection;

298

int CVGraphInterfaceVariationalBC;

299

double NitscheStabilizParam; //Nitsche's stabilization parameter

300

double NitschePenaltyParam; //Nitsche's penalty parameter

301

double ContactTolerance; //Tolerance value for the contact with a simple straight wall handled by the structure

302

bool useSymmetricStress;

303

int NSequationFlag; // Flag to choose implementation method of advective term

304

double stabSUPG; // SUPG stabilization parameter

305

double stabdiv; // stab parameter div div

306

int typeSUPG; // type of SUPG stabilization

307

int NSStabType; // type of stabilization for advection and finite element for NS equation

308

double stabFOVel; // velocity jump coefficient for face-oriented stabilization

309

double stabFOPre; // pressure jump coefficient for face-oriented stabilization

310

int orderPressureExtrapolation; // order of the pressure extrapolation for NSFracStep solvers

311

int incrementalFS;

312

double coefRotScheme; // coef for the rotational incremental NSFracStep solvers

313

int useALEformulation; // 0: no ALE 1: standard ALE, 2: stabilized ALE

314

bool bcInRefConfiguration; // = true means BC are applied on the reference ALE configuration

315

bool useElasticExtension;

316

bool initALEDispByFile;

317

bool updateMeshByVelocity;

318

double theta; // theta parameter (0 \geq theta \geq 1) in the theta-method (time marching)

319

bool nonLinearFluid; //bool non linear solver

int timeScheme;

double gammaNM;

double betaNM;

// Poroelasticity

double biotCoefficient;

double biotModulus;

double isoPermeab;

double anisoPermeab;

int validationTest;

bool scalePressureEq;

// FSI

bool fsiCoupling;

std::string typeOfInterface;

335

int fsiRNscheme;

336

double gammaRN; // Robin parameter for iterative RN coupling with solid

337

bool useLumpedMassRN;

338

bool useMassLumping;

339

std::vector<int> fsiInterfaceLabel;

340

double domainDecompositionToll;

341

int domainDecompositionMaxIt;

bool hasOldMaster;

// ZeroMQ

std::string socketTransport; // communication transport protocol (tcp, ipc, inproc,...)

346

std::string socketAddress; // transport-specific address (interface) to connect to (ex: 127.0.0.1 for localhost)

347

std::string socketPort; // for tcp transport, specifies the port on the interface

348

349

//immersed data for the structure penalisation

350

bool hasImmersedData;

351

std::string meshDirImmersedStruct;

352

std::string meshFileImmersedStruct;

353

double penaltyCoeffImmersedStruct;

354

int allowProjectionImmersedStruct;

355

double valueSourceImmersedStruct;

356

int useMassMatrix; // specify the content of the fourth block of the fluid matrix for the implicit immersed problems. 1: Penalisation coefficient * Mass matrix of the structure. 0: Penalisation coefficient.

357

bool hasDivDivStab; // modification of the SUPG and div div stabilization to improve mass convervation across the valve (cf. Kamensky et al., CMAME, 284, 1005-1053)

358

double localDivDivPenalty;

359

bool divDivStabPostProcess; // boolean to print the results relative to the intersection of the structure mesh with the fluid mesh in files "intersection.****.scl"

360

bool intersectedSubElementsPostProcess; // boolean to print the results relative to the edges of the fluid mesh intersected by the structure mesh in files "intersectedEdges.****.scl"

361

bool useFDlagrangeMult;

362

bool massConstraint;

363

std::vector<felInt> japanLabels;

bool BHstab;

bool BPstab;

double stabCoeffLag;

bool useFicItf;

bool flipItfNormal;

bool useAverageNormal;

370

371

// M1G library interface

struct S_M1G {

bool enable;

int verbose;

std::vector<int> labelPhys;

376

std::vector<int> labelFict;

377

std::vector<felInt> triLst;

378

std::vector<felInt> verLst;

std::string outdir;

bool writeM1Gmeshes;

} M1G;

//fkpp

std::vector<double> sourcePos;

385

386

// Nitsche-XFEM formulation

387

bool useDynamicStructure;

388

bool useGhostPenalty;

389

double coefGhostPenalty;

390

bool useProjectionForNitscheXFEM;

391

bool useInterfaceFlowStab;

392

felInt couplingSchemeStoppingCriteria;

393

bool useODESolve;

394

bool usePenaltyFreeNitscheMethod;

felInt contactDarcy;

double epsDarcy;

double kDarcy;

bool writeXFEMmeshes;

399

bool confIntersection;

400

std::vector<int> structures; // Structure label (mesh file)

401

std::vector<int> numficxstr; // Number of fictitious structure per structure

402

std::vector<int> fictitious; // Fictitious structure label (mesh file)(one or more for evry structure)

403

std::vector<int> meanLabel;

// Solid

double densitySolid;

double young;

double poisson;

double coeffReaction; //coeff for diaphragm and chest reaction - lung model, mechanically induced respiration

double lambda_lame;

double mu_lame;

double thickness;

double alpha_rayleigh;

414

double beta_rayleigh;

415

bool hasRayleighDamping;

416

int planeStressStrain;

417

int volumicOrSurfacicForce;

418

struct CiarletGeymonatType {

double kappa1;

double kappa2;

} CiarletGeymonat;

struct OgdenType {

double C1;

double C2;

double a;

} Ogden;

int nbSubRegions;

int flagJacobi;

double hyperelastic_bulk; // for penalization term in hyperelasticity constitutive law.

431

double volumic_mass;

432

bool hasSolidMidpoint;

433

double solidRadius;

434

std::string typeOfElasticityModel;

435

std::string typeOfShellModel;

436

std::vector<int> contactLabelPair;

437

std::vector<int> rayOrientation;

438

double contactGap;

439

bool evalEnergy;

440

bool velocityConstrained;

// Beam

struct Beam {

int sub_integration;

bool timoshenko;

double diameter;

double inner_diameter;

448

double depth;

449

double cross_area;

450

double effective_area_y;

451

double effective_area_z;

452

double moment_of_intertia_y;

453

double moment_of_intertia_z;

454

double torsional_inertia;

} beam;

//elec

bool hasCoupledAtriaVent;

int orderBdfEdp;

int orderBdfIonic;

//elec - model

std::string typeOfIonicModel;

463

464

std::string CellsType;

465

466

bool spontaneous;

467

bool hasHeteroTauClose;

468

bool hasHeteroCourtPar;

469

bool hasHeteroCondAtria;

470

bool hasAppliedExteriorCurrent;

471

//elec - Schaf solver

bool printIonicVar;

double tauOpen;

double tauClose;

double tauCloseEndo;

double tauCloseCell;

double tauCloseEpi;

double tauCloseRV;

double tauIn;

double tauOut;

double kTanhMSR;

double vMin;

double vMax;

double vGate;

//elec - FhN solver

double epsilon;

double beta;

double gammaEl;

double f0;

double alpha;

//elec - MV solver parameters for inverse problem

492

double tau_so_1_epi;

493

double tau_so_1_endo;

494

double tau_so_1_mcel;

495

double tau_so_1_rv;

496

//elec - MV conductance parameters

double gfi_rv;

double gfi_endo;

double gfi_mid;

double gfi_epi;

double gso_rv;

double gso_endo;

double gso_mid;

double gso_epi;

double gsi_rv;

double gsi_endo;

double gsi_mid;

double gsi_epi;

//elec - Courtemanche solver parameters for inverse problem

double g_Na_PM;

double g_Na_CT;

double g_Na_BB;

//elec - Luenberger filter

514

bool stateFilter;

515

bool schroFilter;

516

bool electrodeControl;

517

double aFilter;

518

double gain;

519

std::string observDir;

520

std::string observFileName;

//elec - parameters

double Am;

double Cm;

bool monodomain;

double extraTransvTensor;

526

double intraTransvTensor;

527

double extraFiberTensor;

528

double intraFiberTensor;

529

double extraTransvTensorAtria;

530

double intraTransvTensorAtria;

531

double extraFiberTensorAtria;

532

double intraFiberTensorAtria;

533

double extraTransvTensorVent;

534

double intraTransvTensorVent;

535

double extraFiberTensorVent;

536

double intraFiberTensorVent;

double sigmaThorax;

double sigmaLung;

double sigmaBone;

//elec - applied current

541

std::string typeOfAppliedCurrent;

542

std::string typeOfAppliedCurrentExt;

//MEA

int NbElectrodes;

std::vector<int> ElecStim;

547

std::vector<double> pulseValues;

548

std::vector<double> pulseValuesDuration;

549

std::vector<std::string> pulseType;

550

std::vector<double> timePeriodMEA;

551

std::vector<double> timePeriodMEAtrain;

552

std::vector<double> trainDuration;

553

std::vector<double> tMaxStim;

554

std::vector<double> Ri;

555

std::vector<double> Rel;

556

std::vector<double> Cel;

557

std::vector<double> Diam;

558

559

double timePeriod;

560

double timePeriodVentricle;

561

double timePeriodAtria;

562

int beatNumber;

563

double beatDecreasing;

564

std::vector<double> delayStim;

565

std::vector<double> delayStimVentricles;

double stimTime;

double stimTimeLV;

double stimTimeRV;

double Iapp_x_coord;

double Iapp_y_coord;

double Iapp_z_coord;

//elec - pathologies

//elec - infarct

bool hasInfarct;

double x_infarct;

double y_infarct;

double z_infarct;

double radius_infarct;

579

//elec - ventricles BBB

580

bool hasVentriclesBundleBrunchBlock;

581

std::string sideOfBBB;

582

bool BBBwithDelay;

583

bool BBBwithAngleBlock;

584

double BBBDelayStim;

585

double angleIappBBB;

586

//elec - Bachmann Bundle Block

587

bool hasPartialBachmannBundleBlock;

588

double valueBBBlock;

589

//elec - Wenckebach atrioventricular Block

590

bool hasWenckebachBlock;

591

//elec - Kent Bundle

592

bool hasKentBundle;

593

//elec - Torsades de pointe

594

bool torsade;

595

double torsadeTimeBegin;

596

double torsadeTimeEnd;

597

double tauCloseTorsade;

598

double tauCloseEndoTorsade;

599

double tauCloseCellTorsade;

600

double tauCloseEpiTorsade;

601

double tauCloseRVTorsade;

602

//elec - ECGwriter

603

bool writeECG;

604

bool writeElectrodesMeas;

605

bool writeElectrodesMean;

606

bool writeMatrixECG;

607

std::string ECGelectrodeFile;

608

std::string ECGmatchFile;

609

std::string ECGThoraxmatchFile;

610

std::string ECGmatrixFile;

611

std::string ECGfileName;

612

bool ECGtabHeader;

613

bool ECGcreateFigure;

614

//elec - dataAssimilation

615

bool dataAssimilation;

double minLSPotTM;

double maxLSPotTM;

double insidePar;

double outsidePar;

//fsi 1D, possibly other parameters for 2D/3D:

622

std::vector<double> betaNormalized;

623

std::vector<double> sectionAtRest;

624

625

//initial condition

626

bool hasInitialCondition; // has or not initial conditions.

627

bool restartSolution; // use previous solution as initial solution.

628

std::string restartSolutionDirRaw; // directory where the initial solution is backed up.

629

std::string restartSolutionDir; // directory where the initial solution is backed up.

630

int restartSolutionIter; // iteration of the backup solution used by the restart.

631

std::vector <std::string> nameVariableInitCond; // variable associate to the IC (to be saved if doing backup).

632

std::vector<std::string> componentInitCond; // components associate to the IC.

633

std::vector<double> valueInitCond; // value associate to the IC.

634

int frequencyBackup; // frequancy of backup (if == 0 , not doing backup copies).

635

636

// Boundary condition

637

int essentialBoundaryConditionsMethod; // 2:penalization or 0:pseudo-elimination.

638

std::vector<std::string> type; // Dirichlet, Neumann, NeumannNormal, Robin, RobinNormal, EmbedFSI.

639

std::vector<std::string> typeValue; // Constant, Vector, FunctionT, FunctionS, FunctionTS or EnsightFile

640

std::vector<int> numLabel; // number of labels concerned by this boundary condition.

641

std::vector<int> label; // label (number) in the mesh file.

642

std::vector<std::string> labelName; // name in the mesh file.

643

std::vector<std::string> variable; // variable to apply BC.

644

std::vector<std::string> component; // components associate to the BC.

645

std::vector<double> value; // value associate to the BC.

646

std::vector<double> userParameter; // container for all others parameters.

647

std::vector<double> alphaRobin; // coeff before variable of Robin BC: betaRobin * grad u dot n + alphaRobin * u = g.

648

std::vector<double> betaRobin; // coeff before normal derivative of Robin BC: betaRobin * grad u dot n + alphaRobin * u = g.

649

std::vector<double> alphaRobinNormal; // coeff before variable of RobinNormal BC

650

double penValueForEmbedFSI; //penalization value for imposing EmbedFSI bc.

651

std::string bcCondDir; // directory of input boundary values files (ensight files).

652

bool useEssDerivedBoundaryCondition;//true if you want to use essential BC DERIVED, even without having any dirichlet BC, added for embedFSI, to impose 0 displacement at the surface boarders

653

std::string modeLung;

654

//TEST_RECUP_DONNEE

655

std::string bc_potExtraCell;

656

657

658

//BCdata x SimplifiedFSI model and boundary condition.

659

//common properties

660

bool switchSimplFSIOff;

double tssParam;

bool tssConsistent;

bool nonLinearKoiterModel;

665

bool zeroDisplacementAtBoarders;

666

double densityStructure;

667

double viscosityStructure;

668

//properties of the shell

double youngShell;

double poissonShell;

double widthShell;

//properties of the fibers

673

double widthFiber;

674

double preStressFibers;

675

double youngFibers;

676

std::vector<double> fiberDensity; // Density of fibers by label (coefficient multiplying (preStressFibers+extraTension) and youngFibers). The list is ordered as the labels defining the EmbedFSI type of BC.

677

double fiberDispersionParameter;

678

double outsidePressure;

679

//properties for 2D testing

double radius;

//other

int idCase;

std::string nameTest;

685

double incomingPressure;

686

double propCardiacCycle;

687

688

//NSHeat

689

double coeffOfThermalExpansion;

690

double thermalDiffusion;

691

double initialTemperature;

692

double referenceTemperature;

693

std::vector<double> gravity;

694

std::vector<felInt> stevinoLabels;

695

double flowRate;

696

697

// data for retinal autoregulation parameters

bool autoregulated;

double maxT;

double q;

double up;

double down;

double nominalPressure;

704

bool useRegulationInWindkessel;

705

std::vector<double> lumpedModelBC_regParam;

706

double windkesselProp;

707

int idControlFreeCase;

708

bool exportPrincipalDirectionsAndCurvature;

709

bool exportDofPartition;

710

711

//IOPcoupling

712

std::vector<int> labelIOPMesh;

713

std::vector<int> labelNSMesh;

714

double porousParam;

715

bool computeSteklov;

716

double relaxationParam;

717

bool exportSteklovData;

718

int optionForSteklov;

719

std::string steklovDataDir;

720

std::string steklovDataDirRaw;

721

std::string steklovMatrixName;

722

int accelerationMethod;

723

double omegaAcceleration;

724

bool lumpedTest;

725

bool notConnectedCylinders;

726

727

bool useRoSteklov;

728

int nbOfLaplacianEigenFunction;

729

double percentageOfExtraEig;

730

int lowRank;

731

bool tryAcceleration;

732

double projOnlineRatio;

733

bool onlyConstResp;

734

735

// export configuration

736

bool exportP1Normal;

737

std::vector<int> labelExportP1Normal;

738

bool exportAll;

739

bool exportLaplacianEigenValues;

740

bool exportLaplacianEigenVectors;

741

bool exportSteklovEigenValues;

742

bool exportSteklovEigenVectors;

743

bool exportFTOfSteklovEigenVectors;

744

bool exportInputOfSteklov;

745

bool exportOutputOfSteklov;

746

bool exportOnlyLastInput;

747

bool exportOnlyLastOutput;

748

bool exportMassMatrix;

749

bool exportLaplacianMatrix;

750

bool exportSteklovMatrix;

751

bool exportReducedEigenMatrix;

752

bool exportOffLineVolumeSolution;

753

bool exportFiltrationVelocity;

754

755

756

std::string bcCondDirRaw; // directory of input boundary values files (ensight files).

//move mesh

bool hasMoveMesh;

bool hasMoveFibers;

std::string MoveMeshMatchFile;

763

double scaleCoeff;

764

765

// bc - lumpedModelBC BC (fluid)

766

std::vector<int> lumpedModelBCType;

767

std::vector<int> lumpedModelBCAlgo;

768

std::vector<int> lumpedModelBCLabel;

769

std::vector<double> lumpedModelBC_Rprox;

770

std::vector<double> lumpedModelBC_Rdist;

771

std::vector<double> lumpedModelBC_C;

772

std::vector<double> lumpedModelBC_Pvenous;

773

std::vector<double> lumpedModelBC_Pdist_init;

774

std::vector<std::string> lumpedModelBCName;

775

776

// linear/non linear compliance (C=C(V))

777

int lumpedModelBC_C_type;

778

int powerNonLinearCompliance;

779

double lumpedModelBC_volumeMax;

780

double lumpedModelBC_volumeMin;

781

// volume at rest

782

double lumpedModelBC_volume0;

783

double lumpedModelBC_referenceVolume0;

784

785

// bc - fluid bc (user parameters)

786

double inflowPressureMaxQuiteInspi;

787

double inflowPressureMaxSpiroInspi;

788

double inflowPressureMaxSpiroExpi;

789

int inflowLabel;

790

791

// bc - to impose the tangential components of the velocity std::vector equal to 0

792

std::vector<int> compTangBClabel;

793

794

//CardiacCycle input condition

795

int CardiacCycleLabel;

796

bool CardiacCycle;

797

double duration_ejection;

798

double duration_isovol_relax;

799

double duration_filling;

800

double duration_isovol_contract;

801

802

double cardiacOutput; // volume of blood ejected per minute (typicaly in liter)

803

double heartRate; // number of heart beat per minute

//FusionDof

bool FusionDof;

std::vector<std::string> FusionVariable; //variable whose dofs have to be fusioned

808

std::vector<int> FusionNumLabel; // total number of labels to be fusioned

809

std::vector<int> FusionLabel; // label (number) in the mesh file.

810

double FusionTolerance;

811

std::vector<bool> AllToOne; // All dofs fusioned in a single one

812

bool AllInLabelToOne; // All dofs of a label fusioned in a single one

813

814

//EmbeddedInterface

815

bool EmbeddedInterface;

816

std::vector<std::string> EmbeddedVariable; //variable whose dofs have to be matched

817

std::vector<int> EmbeddedNumInterface; // total number of labels to be matched

818

std::vector<int> EmbeddedLabelPairs; // label (number) in the mesh file.

819

double EmbeddedMatchTolerance;

//Crack

bool hasCrack;

std::vector<std::string> CrackVariable; // variable used in crack term

824

std::vector<int> CrackNum; // total number of labels indicating crack

825

std::vector<int> CrackLabelPairs; // label (number) in the mesh file.

826

std::vector<int> CrackElemID; // label (number) in the mesh file.

827

double CrackConstant; // working crack "spring" constant

828

double CrackConstantBefore; // crack "spring" constant before cracking

829

double CrackConstantAfter; // crack "spring" constant after cracking

830

double CrackTolerance; // tolerance between points for crack

831

double CrackStressTolerance; // tolerance for stress before switching to "CrackConstant"

832

833

//Penalization valves

834

bool PenalizationMethod;

835

double Gamma_penalization;

836

std::vector<int> closed_penalization;

//RISModels

bool RISModels;

int initiallyOpenedValveIndex; // index of which valve is initially open

841

int crashIfStatusNotAdmissible; // variable to prevent the simulation to stop if a status is not admissible

842

std::vector<int> closed_surf;

843

std::vector<int> open_surf;

844

std::vector<int> fake_surf;

845

int nbTimeSteps_refractory_time; // number of time steps used for defining the refractory time

846

int nbTimeSteps_linear_transition; // number of time steps used for defining the linear evolution in the value of the resistances

847

std::vector<int> nbTimeSteps_linear_transition_twoValves; // number of time steps used for defining the linear evolution in the value of the resistances of the proximal and distal valves

848

double R_active_surf; // resistance of closed valve

849

double R_inactive_surf; // resistance of open valve

850

double R_activeClosed_TwoValves_Intermediate; // resistance of closed valve just after the closing - only used for two valves

851

double R_activeClosed_TwoValves_Final; // final resistance of closed valve after several iterations after the closing - only used for two valves

852

double R_FirstValve_ClosingSpeed; // rate of speed for the evolution of the resistance of the closed surface of the first valve from R_Intermediate to R_Final - only used for two valves

853

double R_SecondValve_ClosingSpeed; // rate of speed for the evolution of the resistance of the closed surface of the second valve from R_Intermediate to R_Final - only used for two valves

854

double flow_ref_oneValve; // flow reference for one valve

855

std::vector<double> flow_ref_twoValves; // flow reference for two valves

856

int preventValvesFromOpeningTooFast; // specify if a closed valve should be prevented from opening if another valve has recently closed

857

int nbIterationsPreventValvesFromOpeningTooFast; // number of iterations during a closed valve cannot open whereas another valve has recently closed

858

int verboseRIS; // verbose for the RIS model

859

860

//Pressure correction for full closed cavity where only displacements are imposed on its boundaries

861

bool useElectroMechanicalPressure; // introducing electromechanical pressure

862

bool usePressureCorrection; // introducing pressure correction

863

bool correctionExternalPressure; // introducing external pressure correction

864

bool correctionALEPressure; // introducing ALE pressure correction

865

int typeOfPressureCorrection; // type of pressure correction. 0 for enabling the pressure correction anytime, 1 only when all the valves are closed.

866

std::vector<int> labelsToCorrectPressure; // vector of labels where the pressure correction is applied

867

std::vector<int> signPressureCorrection; // vector of coefficients (-1 or 1) for the correction of the pressure

868

std::vector<int> labelsToComputeMeanPressure; // vector of labels where the mean pressure is computed and used for the pressure correction

869

std::vector<int> labelsToComputeFluxThrough; // vector of labels where the flux through is computed and used for the ALE pressure correction

870

std::vector<int> exteriorNormalOfLabelsToComputeFluxThrough; // vector of orientation of the exterior normals of the labels where the flux through is computed and used for the ALE pressure correction

871

std::vector<int> forbiddenLabelsForCorrection; // vector of labels where the resistive term called in computeElementArrayBoundaryCondition will not be applied in order to avoid duplications

872

int verbosePressureCorrection; // verbose for the pressure correction

//Stiffening

bool stiffening;

std::vector<int> stiffeningLabels;

877

int skipStiffeningFirstIteration;

double initStiff;

double finalStiff;

//Regurgitation

bool regurgitation;

int regurgitationType;

884

std::vector<double> regurgitationPosition;

885

std::vector<int> regurgitationLabels;

886

double regurgitationRadius;

//ShellModels

// PETSc

int linearSolverVerbose;

892

std::vector<std::string> solver;

893

std::vector<int> gmresRestart;

894

std::vector<std::string> preconditioner;

895

std::vector<std::string> setPreconditionerOption;

896

std::vector<double> relativeTolerance;

897

std::vector<double> absoluteTolerance;

898

std::vector<double> solutionTolerance;

899

std::vector<double> divergenceTolerance;

900

std::vector<int> maxIteration;

901

std::vector<int> maxIterationSNES;

902

std::vector<int> maxFunctionEvaluatedSNES;

903

std::vector<bool> initSolverWithPreviousSolution;

904

905

//verdandi

906

//The background error variance value.

907

double stateErrorVarianceValue;

double Kparameter;

double RHSparameter;

//cvgraph

std::string compartmentName;

913

std::vector<int> interfaceLabels;

914

std::vector<int> correspondingInterfaceLabels;

915

bool withCVG;

916

std::string dataFileCVG;

917

//interpolator parameters (Still in cvgraph section)

918

double interpolatorThreshold;

int maxDepth;

int idVarToExchange;

//ElementField

ElementFieldDynamicValueMapType elementFieldDynamicValueMap;

924

925

// Hyperelastic variables

926

struct hyperElasticLawVariables {

927

std::vector<std::string> type; /// Dirichlet, Neumann, NeumannNormal, Robin, RobinNormal, EmbedFSI.

928

std::vector<int> numLabel; /// Number of labels concerned by this boundary condition.

929

std::vector<int> label; /// Label (number) in the mesh file.

930

Private::Hyperelasticity::PressureData::Pointer pressureData; /// The pressure data considered

931

HyperElasticityLawManager::Pointer hyperElasticLaws; /// Pointer to the hyperelastic law manager considered

932

HyperelasticityNS::TimeScheme timeSchemeHyperelasticity; /// The time scheme considered

} hyperElasticLaw;

};

/**

* @class FelisceParam

938

* @brief Read the felisce data in the data file and on the command line option.

939

*/

940

class FelisceParam

941

: public Singleton<UniqueFelisceParam>

942

{

943

friend class Singleton<UniqueFelisceParam>;

protected:

FelisceParam();

virtual ~FelisceParam();

public:

/*

Folling data are read in configuration file and on the command line.

953

They are grouped by configuration file sections.

954

*/

955

956

30281

static const int& verbose(const std::size_t instanceIndex = 0) {

957

30281

return FelisceParam::instance(instanceIndex).m_verbose;

958

}

959

960

static const bool& chronoToFile(const std::size_t instanceIndex = 0) {

961

return FelisceParam::instance(instanceIndex).chronoToFile;

962

}

963

964

4

static void linearSolverVerboseOFF(const std::size_t instanceIndex = 0) {

965

4

FelisceParam::instance(instanceIndex).tmpLinSolverVerbose = FelisceParam::instance(instanceIndex).linearSolverVerbose;

966

4

FelisceParam::instance(instanceIndex).linearSolverVerbose = 0;

967

4

}

968

969

4

static void linearSolverVerboseON(const std::size_t instanceIndex = 0) {

970

/// Use it ONLY after the OFF version!

971

4

FelisceParam::instance(instanceIndex).linearSolverVerbose = FelisceParam::instance(instanceIndex).tmpLinSolverVerbose;

972

4

}

973

974

15

static void alterVerbosity(int newValue, const std::size_t instanceIndex = 0) {

975

15

FelisceParam::instance(instanceIndex).m_refVerbose=FelisceParam::instance(instanceIndex).m_verbose;

976

15

FelisceParam::instance(instanceIndex).m_verbose=newValue;

977

15

}

978

static void restoreVerbosity(const std::size_t instanceIndex = 0) {

979

/// Use it ONLY after alterVerbosity

980

FelisceParam::instance(instanceIndex).m_verbose=FelisceParam::instance(instanceIndex).m_refVerbose;

}

};

}

#endif