From 198f4c6927f224a12474d587fc1726e90ff228a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?G=C3=A9rard=20Rio?= Date: Thu, 20 Jun 2024 15:42:40 +0200 Subject: [PATCH] =?UTF-8?q?version=20interm=C3=A9diaire=207.033,=20mise=20?= =?UTF-8?q?en=20place=20d'I/O=20MPI=20sur=20.BI=20:=20partie=20algos=20,?= =?UTF-8?q?=20objectif=20validation=20de=20la=20m=C3=A9thodologie=20(sorti?= =?UTF-8?q?e=20diff=C3=A9r=C3=A9e=20avec=20bufferisation)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Algo/AlgoRef/Algori.cc | 3 + Algo/AlgoRef/Algori.h | 56 +- Algo/AlgoRef/Algori2.cc | 412 +++++++-- Algo/AlgoUtilitaires/AlgoInformations.h | 4 +- Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc | 8 +- Algo/AlgoUtilitaires/AlgoUmatAbaqus.h | 4 +- Algo/AlgoUtilitaires/AlgoUtils.h | 4 +- Algo/AlgorithmeCombiner/AlgoriCombine.cc | 40 +- Algo/AlgorithmeCombiner/AlgoriCombine.h | 10 +- Algo/AlgorithmeCombiner/AlgoriCombine2.cc | 6 +- .../AlgoDynaExplicite/AlgoRungeKutta.cc | 25 +- .../AlgoDynaExplicite/AlgoRungeKutta.h | 4 +- .../AlgoDynaExplicite/AlgoriDynaExpli.cc | 22 +- .../AlgoDynaExplicite/AlgoriDynaExpli.h | 4 +- .../AlgoDynaExplicite/AlgoriDynaExpli2.cc | 14 +- .../AlgoDynaExplicite/AlgoriDynaExpli_zhai.cc | 44 +- .../AlgoDynaExplicite/AlgoriDynaExpli_zhai.h | 4 +- .../AlgoDynaExplicite/Algori_chung_lee.cc | 25 +- .../AlgoDynaExplicite/Algori_chung_lee.h | 4 +- .../AlgoDynaExplicite/Algori_relax_dyna.cc | 21 +- .../AlgoDynaExplicite/Algori_relax_dyna.h | 4 +- .../AlgoDynaExplicite/Algori_tchamwa.cc | 29 +- .../AlgoDynaExplicite/Algori_tchamwa.h | 4 +- .../AlgoDynaExplicite/Algori_tchamwa2.cc | 12 +- .../AlgoDynaImplicite/AlgoriNewmark.cc | 27 +- .../AlgoDynaImplicite/AlgoriNewmark.h | 4 +- .../AlgoDynaImplicite/AlgoriNewmark2.cc | 4 +- Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.cc | 25 +- Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.h | 4 +- .../AlgoStatiques/AlgoriFlambLineaire.cc | 26 +- .../AlgoStatiques/AlgoriFlambLineaire.h | 4 +- .../AlgoStatiques/AlgoriNonDyna.cc | 54 +- .../AlgoStatiques/AlgoriNonDyna.h | 4 +- .../AlgoStatiques/AlgoriNonDyna2.cc | 10 +- .../AlgoStatiques/ImpliNonDynaCont.cc | 7 +- .../AlgoStatiques/ImpliNonDynaCont.h | 4 +- .../DG_DynaExplicite/AlgoBonelli.cc | 21 +- .../DG_DynaExplicite/AlgoBonelli.h | 4 +- Chargement/BlocCharge_T.h | 4 +- Chargement/Charge.cc | 8 +- Chargement/Charge.h | 4 +- Chargement/VariablesTemps.cc | 8 +- Chargement/VariablesTemps.h | 4 +- Elements/Element.cc | 6 +- Elements/Element.h | 10 +- Elements/Geometrie/Frontiere/ElFrontiere.cc | 4 +- Elements/Geometrie/Frontiere/ElFrontiere.h | 8 +- Elements/Geometrie/Frontiere/Front.cc | 4 +- Elements/Geometrie/Frontiere/Front.h | 6 +- .../Geometrie/Frontiere/Ligne/FrontSegCub.cc | 4 +- .../Geometrie/Frontiere/Ligne/FrontSegCub.h | 4 +- .../Geometrie/Frontiere/Ligne/FrontSegLine.cc | 4 +- .../Geometrie/Frontiere/Ligne/FrontSegLine.h | 4 +- .../Geometrie/Frontiere/Ligne/FrontSegQuad.cc | 4 +- .../Geometrie/Frontiere/Ligne/FrontSegQuad.h | 4 +- .../Geometrie/Frontiere/Point/FrontPointF.cc | 4 +- .../Geometrie/Frontiere/Point/FrontPointF.h | 4 +- .../Frontiere/Surface/FrontQuadCC.cc | 4 +- .../Geometrie/Frontiere/Surface/FrontQuadCC.h | 4 +- .../Frontiere/Surface/FrontQuadLine.cc | 4 +- .../Frontiere/Surface/FrontQuadLine.h | 4 +- .../Frontiere/Surface/FrontQuadQC.cc | 4 +- .../Geometrie/Frontiere/Surface/FrontQuadQC.h | 4 +- .../Frontiere/Surface/FrontQuadQuad.cc | 4 +- .../Frontiere/Surface/FrontQuadQuad.h | 4 +- .../Frontiere/Surface/FrontTriaLine.cc | 4 +- .../Frontiere/Surface/FrontTriaLine.h | 4 +- .../Frontiere/Surface/FrontTriaQuad.cc | 4 +- .../Frontiere/Surface/FrontTriaQuad.h | 4 +- Elements/Mecanique/Biellette/Biel_axi.cc | 10 +- Elements/Mecanique/Biellette/Biel_axi.h | 6 +- Elements/Mecanique/Biellette/Biel_axiQ.cc | 10 +- Elements/Mecanique/Biellette/Biel_axiQ.h | 6 +- Elements/Mecanique/Biellette/Biellette.cc | 10 +- Elements/Mecanique/Biellette/Biellette.h | 6 +- Elements/Mecanique/Biellette/BielletteC1.cc | 10 +- Elements/Mecanique/Biellette/BielletteC1.h | 6 +- Elements/Mecanique/Biellette/BielletteQ.cc | 10 +- Elements/Mecanique/Biellette/BielletteQ.h | 6 +- Elements/Mecanique/Biellette/PoutSimple1.cc | 10 +- Elements/Mecanique/Biellette/PoutSimple1.h | 6 +- Elements/Mecanique/Biellette/PoutTimo.cc | 2 +- Elements/Mecanique/Biellette/PoutTimo.h | 2 +- .../Mecanique/Deformation_gene/Deformation.h | 10 +- .../DeformationSfe1_stockage.cc | 8 +- .../Deformation_gene/Deformation_stockage.cc | 8 +- Elements/Mecanique/ElemMeca.cc | 8 +- Elements/Mecanique/ElemMeca.h | 18 +- Elements/Mecanique/ElemMeca2.cc | 10 +- Elements/Mecanique/ElemMeca4.cc | 10 +- Elements/Mecanique/ElemMecaGene.h | 10 +- Elements/Mecanique/ElemPoint/ElemPoint.cc | 10 +- Elements/Mecanique/ElemPoint/ElemPoint.h | 6 +- Elements/Mecanique/ElemPoint/UmatAbaqus.cc | 6 +- Elements/Mecanique/ElemPoint/UmatAbaqus.h | 6 +- Elements/Mecanique/Hexaedre/Hexa.cc | 2 +- Elements/Mecanique/Hexaedre/Hexa.h | 2 +- Elements/Mecanique/Hexaedre/HexaLMemb.cc | 2 +- Elements/Mecanique/Hexaedre/HexaLMemb.h | 2 +- Elements/Mecanique/Hexaedre/HexaMemb.cc | 8 +- Elements/Mecanique/Hexaedre/HexaMemb.h | 4 +- Elements/Mecanique/Hexaedre/HexaQ.cc | 2 +- Elements/Mecanique/Hexaedre/HexaQ.h | 2 +- Elements/Mecanique/Hexaedre/HexaQComp.cc | 2 +- Elements/Mecanique/Hexaedre/HexaQComp.h | 2 +- Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc | 2 +- .../Mecanique/Hexaedre/HexaQComp_27pti.cc | 2 +- .../Mecanique/Hexaedre/HexaQComp_64pti.cc | 2 +- .../Mecanique/Hexaedre/HexaQComp_cm1pti.h | 2 +- .../Mecanique/Hexaedre/HexaQComp_cm27pti.h | 2 +- .../Mecanique/Hexaedre/HexaQComp_cm64pti.h | 2 +- Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc | 2 +- Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h | 2 +- Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc | 2 +- Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h | 2 +- Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc | 2 +- Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h | 2 +- Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc | 2 +- Elements/Mecanique/Hexaedre/Hexa_cm1pti.h | 2 +- Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc | 2 +- Elements/Mecanique/Hexaedre/Hexa_cm27pti.h | 2 +- Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc | 2 +- Elements/Mecanique/Hexaedre/Hexa_cm64pti.h | 2 +- Elements/Mecanique/LesChargeExtSurElement.cc | 4 +- Elements/Mecanique/LesChargeExtSurElement.h | 4 +- Elements/Mecanique/LesPtIntegMecaInterne.cc | 8 +- Elements/Mecanique/LesPtIntegMecaInterne.h | 4 +- Elements/Mecanique/Pentaedre/PentaL.cc | 2 +- Elements/Mecanique/Pentaedre/PentaL.h | 2 +- Elements/Mecanique/Pentaedre/PentaL_cm1pti.cc | 2 +- Elements/Mecanique/Pentaedre/PentaL_cm1pti.h | 2 +- Elements/Mecanique/Pentaedre/PentaL_cm2pti.cc | 2 +- Elements/Mecanique/Pentaedre/PentaL_cm2pti.h | 2 +- Elements/Mecanique/Pentaedre/PentaL_cm6pti.cc | 2 +- Elements/Mecanique/Pentaedre/PentaL_cm6pti.h | 2 +- Elements/Mecanique/Pentaedre/PentaMemb.cc | 8 +- Elements/Mecanique/Pentaedre/PentaMemb.h | 4 +- Elements/Mecanique/Pentaedre/PentaQ.cc | 2 +- Elements/Mecanique/Pentaedre/PentaQ.h | 2 +- Elements/Mecanique/Pentaedre/PentaQComp.cc | 2 +- Elements/Mecanique/Pentaedre/PentaQComp.h | 2 +- .../Mecanique/Pentaedre/PentaQComp_cm12pti.cc | 2 +- .../Mecanique/Pentaedre/PentaQComp_cm12pti.h | 2 +- .../Mecanique/Pentaedre/PentaQComp_cm18pti.cc | 2 +- .../Mecanique/Pentaedre/PentaQComp_cm18pti.h | 2 +- .../Mecanique/Pentaedre/PentaQComp_cm9pti.cc | 2 +- .../Mecanique/Pentaedre/PentaQComp_cm9pti.h | 2 +- .../Mecanique/Pentaedre/PentaQ_cm12pti.cc | 2 +- Elements/Mecanique/Pentaedre/PentaQ_cm12pti.h | 2 +- .../Mecanique/Pentaedre/PentaQ_cm18pti.cc | 2 +- Elements/Mecanique/Pentaedre/PentaQ_cm18pti.h | 2 +- Elements/Mecanique/Pentaedre/PentaQ_cm3pti.cc | 2 +- Elements/Mecanique/Pentaedre/PentaQ_cm3pti.h | 2 +- Elements/Mecanique/Pentaedre/PentaQ_cm9pti.cc | 2 +- Elements/Mecanique/Pentaedre/PentaQ_cm9pti.h | 2 +- Elements/Mecanique/PtIntegMecaInterne.cc | 4 +- Elements/Mecanique/PtIntegMecaInterne.h | 4 +- .../Mecanique/Quad_asisymetrie/QuadAxiCCom.cc | 2 +- .../Mecanique/Quad_asisymetrie/QuadAxiCCom.h | 2 +- .../Quad_asisymetrie/QuadAxiCCom_cm9pti.cc | 2 +- .../Quad_asisymetrie/QuadAxiCCom_cm9pti.h | 2 +- .../Mecanique/Quad_asisymetrie/QuadAxiL1.cc | 2 +- .../Mecanique/Quad_asisymetrie/QuadAxiL1.h | 2 +- .../Quad_asisymetrie/QuadAxiL1_cm1pti.cc | 2 +- .../Quad_asisymetrie/QuadAxiL1_cm1pti.h | 2 +- .../Mecanique/Quad_asisymetrie/QuadAxiMemb.cc | 8 +- .../Mecanique/Quad_asisymetrie/QuadAxiMemb.h | 4 +- .../Mecanique/Quad_asisymetrie/QuadAxiQ.cc | 2 +- .../Mecanique/Quad_asisymetrie/QuadAxiQ.h | 2 +- .../Quad_asisymetrie/QuadAxiQComp.cc | 2 +- .../Mecanique/Quad_asisymetrie/QuadAxiQComp.h | 2 +- .../Quad_asisymetrie/QuadAxiQComp_cm4pti.cc | 2 +- .../Quad_asisymetrie/QuadAxiQComp_cm4pti.h | 2 +- Elements/Mecanique/SFE/DeformationSfe1.h | 10 +- Elements/Mecanique/SFE/SfeMembT.cc | 8 +- Elements/Mecanique/SFE/SfeMembT.h | 4 +- Elements/Mecanique/SFE/TriaQSfe1.cc | 2 +- Elements/Mecanique/SFE/TriaQSfe1.h | 2 +- Elements/Mecanique/SFE/TriaQSfe3.cc | 2 +- Elements/Mecanique/SFE/TriaQSfe3.h | 2 +- Elements/Mecanique/SFE/TriaSfe1.cc | 2 +- Elements/Mecanique/SFE/TriaSfe1.h | 2 +- Elements/Mecanique/SFE/TriaSfe1_cm5pti.cc | 2 +- Elements/Mecanique/SFE/TriaSfe1_cm5pti.h | 2 +- Elements/Mecanique/SFE/TriaSfe2.cc | 2 +- Elements/Mecanique/SFE/TriaSfe2.h | 2 +- Elements/Mecanique/SFE/TriaSfe3.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3.h | 2 +- Elements/Mecanique/SFE/TriaSfe3C.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3C.h | 2 +- Elements/Mecanique/SFE/TriaSfe3_3D.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3_3D.h | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm12pti.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm12pti.h | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm13pti.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm13pti.h | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm3pti.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm3pti.h | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm4pti.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm4pti.h | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm5pti.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm5pti.h | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm6pti.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm6pti.h | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm7pti.cc | 2 +- Elements/Mecanique/SFE/TriaSfe3_cm7pti.h | 2 +- Elements/Mecanique/Tetraedre/Tetra.cc | 2 +- Elements/Mecanique/Tetraedre/Tetra.h | 2 +- Elements/Mecanique/Tetraedre/TetraMemb.cc | 8 +- Elements/Mecanique/Tetraedre/TetraMemb.h | 4 +- Elements/Mecanique/Tetraedre/TetraQ.cc | 2 +- Elements/Mecanique/Tetraedre/TetraQ.h | 2 +- .../Mecanique/Tetraedre/TetraQ_cm15pti.cc | 2 +- Elements/Mecanique/Tetraedre/TetraQ_cm15pti.h | 2 +- Elements/Mecanique/Tetraedre/TetraQ_cm1pti.cc | 2 +- Elements/Mecanique/Tetraedre/TetraQ_cm1pti.h | 2 +- .../Mecanique/Tria_axisymetrie/TriaAxiL1.cc | 2 +- .../Mecanique/Tria_axisymetrie/TriaAxiL1.h | 2 +- .../Mecanique/Tria_axisymetrie/TriaAxiMemb.cc | 8 +- .../Mecanique/Tria_axisymetrie/TriaAxiMemb.h | 4 +- .../Mecanique/Tria_axisymetrie/TriaAxiQ3.cc | 2 +- .../Mecanique/Tria_axisymetrie/TriaAxiQ3.h | 2 +- .../Tria_axisymetrie/TriaAxiQ3_cm1pti.cc | 2 +- .../Tria_axisymetrie/TriaAxiQ3_cm1pti.h | 2 +- .../Tria_axisymetrie/TriaAxiQ3_cmpti1003.cc | 2 +- .../Tria_axisymetrie/TriaAxiQ3_cmpti1003.h | 2 +- Elements/Mecanique/Triangle/TriaCub.cc | 2 +- Elements/Mecanique/Triangle/TriaCub.h | 2 +- Elements/Mecanique/Triangle/TriaCub_cm4pti.cc | 2 +- Elements/Mecanique/Triangle/TriaCub_cm4pti.h | 2 +- Elements/Mecanique/Triangle/TriaMemb.cc | 8 +- Elements/Mecanique/Triangle/TriaMemb.h | 4 +- Elements/Mecanique/Triangle/TriaMembL1.cc | 2 +- Elements/Mecanique/Triangle/TriaMembL1.h | 2 +- Elements/Mecanique/Triangle/TriaMembQ3.cc | 2 +- Elements/Mecanique/Triangle/TriaMembQ3.h | 2 +- .../Mecanique/Triangle/TriaMembQ3_cm1pti.cc | 2 +- .../Mecanique/Triangle/TriaMembQ3_cm1pti.h | 2 +- .../Mecanique/Triangle/TriaQ3_cmpti1003.cc | 2 +- .../Mecanique/Triangle/TriaQ3_cmpti1003.h | 2 +- Elements/Mecanique/quadrangle/Quad.cc | 2 +- Elements/Mecanique/quadrangle/Quad.h | 2 +- Elements/Mecanique/quadrangle/QuadCCom.cc | 2 +- Elements/Mecanique/quadrangle/QuadCCom.h | 2 +- .../Mecanique/quadrangle/QuadCCom_cm9pti.cc | 2 +- .../Mecanique/quadrangle/QuadCCom_cm9pti.h | 2 +- Elements/Mecanique/quadrangle/QuadQ.cc | 2 +- Elements/Mecanique/quadrangle/QuadQ.h | 2 +- Elements/Mecanique/quadrangle/QuadQCom.cc | 2 +- Elements/Mecanique/quadrangle/QuadQCom.h | 2 +- .../Mecanique/quadrangle/QuadQCom_cm4pti.cc | 2 +- .../Mecanique/quadrangle/QuadQCom_cm4pti.h | 2 +- Elements/Mecanique/quadrangle/Quad_cm1pti.cc | 2 +- Elements/Mecanique/quadrangle/Quad_cm1pti.h | 2 +- Elements/Mecanique/quadrangle/QuadraMemb.cc | 8 +- Elements/Mecanique/quadrangle/QuadraMemb.h | 4 +- Elements/ResRaid_MPI.cc | 4 +- Elements/ResRaid_MPI.h | 4 +- .../Thermique/Biellette/BielletteThermi.cc | 10 +- .../Thermique/Biellette/BielletteThermi.h | 6 +- Elements/Thermique/ElemThermi.h | 14 +- Elements/Thermique/ElemThermi2.cc | 8 +- Elements/Thermique/ElemThermi4.cc | 10 +- Elements/Thermique/LesPtIntegThermiInterne.cc | 8 +- Elements/Thermique/LesPtIntegThermiInterne.h | 4 +- Elements/Thermique/PtIntegThermiInterne.cc | 4 +- Elements/Thermique/PtIntegThermiInterne.h | 4 +- Enumeration/EnumTypeCalcul.cc | 2 +- Flambage/LesValVecPropres.cc | 4 +- Flambage/LesValVecPropres.h | 2 +- General/Distribution_CPU.cc | 4 +- General/Distribution_CPU.h | 4 +- General/Projet.cc | 5 +- General/Projet.h | 2 +- General/Projet2.cc | 2 +- Lecture/UtilLecture.cc | 25 +- Lecture/UtilLecture.h | 60 +- Lecture/nouvelle_enreg.cc | 86 +- Lecture/utilLecture2.cc | 785 ++++++++++++------ Maillage/DdlLim.cc | 2 +- Maillage/DdlLim.h | 2 +- Maillage/DiversStockage.cc | 4 +- Maillage/DiversStockage.h | 4 +- Maillage/I_O_Condilineaire.cc | 2 +- Maillage/I_O_Condilineaire.h | 2 +- Maillage/LesCondLim.cc | 6 +- Maillage/LesCondLim.h | 6 +- Maillage/LesMaillages.cc | 38 +- Maillage/LesMaillages.h | 8 +- Maillage/LesMaillages2.cc | 6 +- Maillage/Maillage.cc | 487 ++++++++--- Maillage/Maillage.h | 22 +- Maillage/Maillage2.cc | 2 +- Maillage/Noeud.cc | 12 +- Maillage/Noeud.h | 10 +- Maillage/Noeud2.cc | 2 +- Maillage/VariablesExporter.cc | 131 ++- Maillage/VariablesExporter.h | 22 +- Parametres/Banniere.h | 4 +- Parametres/EnteteParaGlob.h | 2 +- Parametres/ParaAlgoControle.cc | 4 +- Parametres/ParaAlgoControle.h | 4 +- Parametres/ParaGlob.cc | 131 ++- Parametres/ParaGlob.h | 20 +- Parametres/banniere.cc | 4 +- References/LesReferences.cc | 4 +- References/LesReferences.h | 4 +- References/Reference.cc | 4 +- References/Reference.h | 10 +- References/ReferenceAF.cc | 6 +- References/ReferenceAF.h | 6 +- References/ReferenceNE.cc | 6 +- References/ReferenceNE.h | 6 +- References/ReferencePtiAF.cc | 6 +- References/ReferencePtiAF.h | 6 +- Resolin/Resolution_Condi/Condilineaire.cc | 4 +- Resolin/Resolution_Condi/Condilineaire.h | 4 +- Resultats/Resultats.cc | 31 +- Resultats/Resultats.h | 4 +- TypeBase/Basiques.cc | 22 +- TypeBase/Basiques.h | 22 +- TypeBase/Ponderation.cc | 32 +- TypeBase/Ponderation.h | 36 +- TypeBase/Temps_CPU_HZpp.cc | 2 +- TypeBase/Temps_CPU_HZpp.h | 2 +- TypeBase/Temps_CPU_HZpp_3.cc | 2 +- TypeBase/Temps_CPU_HZpp_3.h | 2 +- Util/Algo_zero.cc | 4 +- Util/Algo_zero.h | 4 +- Util/CharUtil.cc | 2 +- Util/CharUtil.h | 2 +- Util/Courbes/Courbe1D.h | 6 +- Util/Courbes/CourbePolyHermite1D.cc | 6 +- Util/Courbes/CourbePolyHermite1D.h | 6 +- Util/Courbes/CourbePolyLineaire.cc | 6 +- Util/Courbes/CourbePolyLineaire1D.h | 6 +- Util/Courbes/CourbePolyLineaire1D_simpli.cc | 2 +- Util/Courbes/CourbePolyLineaire1D_simpli.h | 2 +- Util/Courbes/CourbePolynomiale.cc | 6 +- Util/Courbes/CourbePolynomiale.h | 6 +- Util/Courbes/Courbe_cos.cc | 6 +- Util/Courbes/Courbe_cos.h | 6 +- Util/Courbes/Courbe_expo2_n.cc | 6 +- Util/Courbes/Courbe_expo2_n.h | 6 +- Util/Courbes/Courbe_expo_n.cc | 6 +- Util/Courbes/Courbe_expo_n.h | 6 +- Util/Courbes/Courbe_expoaff.cc | 6 +- Util/Courbes/Courbe_expoaff.h | 6 +- .../Courbes/Courbe_expression_litterale_1D.cc | 6 +- Util/Courbes/Courbe_expression_litterale_1D.h | 6 +- ...e_expression_litterale_avec_derivees_1D.cc | 6 +- ...be_expression_litterale_avec_derivees_1D.h | 6 +- Util/Courbes/Courbe_ln_cosh.cc | 6 +- Util/Courbes/Courbe_ln_cosh.h | 6 +- Util/Courbes/Courbe_relax_expo.cc | 6 +- Util/Courbes/Courbe_relax_expo.h | 6 +- Util/Courbes/Courbe_sin.cc | 6 +- Util/Courbes/Courbe_sin.h | 6 +- Util/Courbes/Courbe_un_moins_cos.cc | 6 +- Util/Courbes/Courbe_un_moins_cos.h | 6 +- Util/Courbes/F1_plus_F2.cc | 6 +- Util/Courbes/F1_plus_F2.h | 6 +- Util/Courbes/F1_rond_F2.cc | 6 +- Util/Courbes/F1_rond_F2.h | 6 +- Util/Courbes/F_cycle_add.cc | 8 +- Util/Courbes/F_cycle_add.h | 6 +- Util/Courbes/F_cyclique.cc | 8 +- Util/Courbes/F_cyclique.h | 6 +- Util/Courbes/F_nD_courbe1D.cc | 8 +- Util/Courbes/F_nD_courbe1D.h | 6 +- Util/Courbes/F_union_1D.cc | 6 +- Util/Courbes/F_union_1D.h | 6 +- Util/Courbes/Fonc_scal_combinees_nD.cc | 6 +- Util/Courbes/Fonc_scal_combinees_nD.h | 6 +- .../Fonction_expression_litterale_nD.cc | 6 +- .../Fonction_expression_litterale_nD.h | 6 +- Util/Courbes/Fonction_externe_nD.cc | 6 +- Util/Courbes/Fonction_externe_nD.h | 6 +- Util/Courbes/Fonction_nD.cc | 6 +- Util/Courbes/Fonction_nD.h | 12 +- Util/Courbes/LesCourbes1D.cc | 10 +- Util/Courbes/LesCourbes1D.h | 10 +- Util/Courbes/LesFonctions_nD.cc | 10 +- Util/Courbes/LesFonctions_nD.h | 10 +- Util/Courbes/Poly_Lagrange.cc | 6 +- Util/Courbes/Poly_Lagrange.h | 6 +- Util/Courbes/SixpodeCos3phi.cc | 6 +- Util/Courbes/SixpodeCos3phi.h | 6 +- Util/Courbes/TangenteHyperbolique.cc | 8 +- Util/Courbes/TangenteHyperbolique.h | 6 +- Util/Courbes/TripodeCos3phi.cc | 6 +- Util/Courbes/TripodeCos3phi.h | 6 +- comportement/CompFrotAbstraite.h | 10 +- comportement/CompThermoPhysiqueAbstraite.h | 10 +- comportement/Frottement/CompFrotCoulomb.cc | 4 +- comportement/Frottement/CompFrotCoulomb.h | 8 +- comportement/Hyper_elastique/Hart_Smith3D.cc | 4 +- comportement/Hyper_elastique/Hart_Smith3D.h | 4 +- comportement/Hyper_elastique/Hyper3D.cc | 4 +- comportement/Hyper_elastique/Hyper3D.h | 4 +- comportement/Hyper_elastique/HyperD.cc | 4 +- comportement/Hyper_elastique/HyperD.h | 10 +- comportement/Hyper_elastique/HyperDN.h | 6 +- .../Hyper_elastique/Hyper_W_gene_3D.cc | 4 +- .../Hyper_elastique/Hyper_W_gene_3D.h | 4 +- .../Hyper_elastique/Hyper_externe_W.cc | 8 +- .../Hyper_elastique/Hyper_externe_W.h | 10 +- .../Hyper_elastique/IsoHyper3DFavier3.cc | 8 +- .../Hyper_elastique/IsoHyper3DFavier3.h | 8 +- .../Hyper_elastique/IsoHyper3DOrgeas1.cc | 4 +- .../Hyper_elastique/IsoHyper3DOrgeas1.h | 4 +- .../Hyper_elastique/IsoHyper3DOrgeas2.cc | 4 +- .../Hyper_elastique/IsoHyper3DOrgeas2.h | 4 +- comportement/Hyper_elastique/IsoHyperBulk3.cc | 4 +- comportement/Hyper_elastique/IsoHyperBulk3.h | 4 +- .../Hyper_elastique/IsoHyperBulk_gene.cc | 4 +- .../Hyper_elastique/IsoHyperBulk_gene.h | 4 +- comportement/Hyper_elastique/Maheo_hyper.cc | 4 +- comportement/Hyper_elastique/Maheo_hyper.h | 4 +- .../Hyper_elastique/MooneyRivlin1D.cc | 4 +- comportement/Hyper_elastique/MooneyRivlin1D.h | 4 +- .../Hyper_elastique/MooneyRivlin3D.cc | 4 +- comportement/Hyper_elastique/MooneyRivlin3D.h | 4 +- comportement/Hyper_elastique/Poly_hyper3D.cc | 4 +- comportement/Hyper_elastique/Poly_hyper3D.h | 4 +- comportement/Hyper_elastique/TreloarN.cc | 4 +- comportement/Hyper_elastique/TreloarN.h | 4 +- comportement/Hypo_elastique/Hypo_hooke1D.cc | 8 +- comportement/Hypo_elastique/Hypo_hooke1D.h | 8 +- comportement/Hypo_elastique/Hypo_hooke2D_C.cc | 8 +- comportement/Hypo_elastique/Hypo_hooke2D_C.h | 8 +- comportement/Hypo_elastique/Hypo_hooke3D.cc | 8 +- comportement/Hypo_elastique/Hypo_hooke3D.h | 8 +- comportement/LesLoisDeComp.cc | 16 +- comportement/LesLoisDeComp.h | 12 +- comportement/LoiAbstraiteGeneral.cc | 4 +- comportement/LoiAbstraiteGeneral.h | 8 +- comportement/Loi_comp_abstraite.cc | 8 +- comportement/Loi_comp_abstraite.h | 18 +- .../anisotropie/Hypo_ortho3D_entrainee.cc | 8 +- .../anisotropie/Hypo_ortho3D_entrainee.h | 8 +- .../anisotropie/Loi_ortho2D_C_entrainee.cc | 8 +- .../anisotropie/Loi_ortho2D_C_entrainee.h | 8 +- .../anisotropie/Loi_ortho3D_entrainee.cc | 8 +- .../anisotropie/Loi_ortho3D_entrainee.h | 8 +- .../anisotropie/Projection_anisotrope_3D.cc | 8 +- .../anisotropie/Projection_anisotrope_3D.h | 8 +- comportement/hysteresis/Hysteresis1D.cc | 8 +- comportement/hysteresis/Hysteresis1D.h | 8 +- comportement/hysteresis/Hysteresis3D.cc | 8 +- comportement/hysteresis/Hysteresis3D.h | 8 +- comportement/hysteresis/Hysteresis_bulk.cc | 8 +- comportement/hysteresis/Hysteresis_bulk.h | 8 +- comportement/iso_elas_hooke/Loi_iso_elas1D.cc | 4 +- comportement/iso_elas_hooke/Loi_iso_elas1D.h | 8 +- .../iso_elas_hooke/Loi_iso_elas2D_C.cc | 8 +- .../iso_elas_hooke/Loi_iso_elas2D_C.h | 8 +- .../iso_elas_hooke/Loi_iso_elas2D_D.cc | 4 +- .../iso_elas_hooke/Loi_iso_elas2D_D.h | 8 +- comportement/iso_elas_hooke/Loi_iso_elas3D.cc | 4 +- comportement/iso_elas_hooke/Loi_iso_elas3D.h | 8 +- .../iso_elas_nonlinear/Iso_elas_SE1D.cc | 4 +- .../iso_elas_nonlinear/Iso_elas_SE1D.h | 4 +- .../iso_elas_nonlinear/Iso_elas_expo1D.cc | 4 +- .../iso_elas_nonlinear/Iso_elas_expo1D.h | 8 +- .../iso_elas_nonlinear/Iso_elas_expo3D.h | 4 +- .../iso_elas_nonlinear/iso_elas_expo3D.cc | 4 +- comportement/loi_Umat/Loi_Umat.cc | 8 +- comportement/loi_Umat/Loi_Umat.h | 8 +- .../lois_combinees/LoiAdditiveEnSigma.cc | 12 +- .../lois_combinees/LoiAdditiveEnSigma.h | 8 +- .../lois_combinees/LoiContraintesPlanes.cc | 8 +- .../lois_combinees/LoiContraintesPlanes.h | 8 +- .../LoiContraintesPlanesDouble.cc | 8 +- .../LoiContraintesPlanesDouble.h | 8 +- comportement/lois_combinees/LoiCritere.cc | 8 +- comportement/lois_combinees/LoiCritere.h | 8 +- .../lois_combinees/LoiDeformationsPlanes.cc | 8 +- .../lois_combinees/LoiDeformationsPlanes.h | 8 +- .../lois_combinees/LoiDesMelangesEnSigma.cc | 8 +- .../lois_combinees/LoiDesMelangesEnSigma.h | 8 +- comportement/lois_speciales/Loi_rien1D.cc | 4 +- comportement/lois_speciales/Loi_rien1D.h | 4 +- comportement/lois_speciales/Loi_rien2D_C.cc | 4 +- comportement/lois_speciales/Loi_rien2D_C.h | 4 +- comportement/lois_speciales/Loi_rien2D_D.cc | 4 +- comportement/lois_speciales/Loi_rien2D_D.h | 4 +- comportement/lois_speciales/Loi_rien3D.cc | 4 +- comportement/lois_speciales/Loi_rien3D.h | 4 +- .../lois_visco_elastiques/Loi_maxwell1D.cc | 4 +- .../lois_visco_elastiques/Loi_maxwell1D.h | 4 +- .../lois_visco_elastiques/Loi_maxwell2D_C.cc | 8 +- .../lois_visco_elastiques/Loi_maxwell2D_C.h | 8 +- .../lois_visco_elastiques/Loi_maxwell2D_D.cc | 8 +- .../lois_visco_elastiques/Loi_maxwell2D_D.h | 8 +- .../lois_visco_elastiques/Loi_maxwell3D.cc | 4 +- .../lois_visco_elastiques/Loi_maxwell3D.h | 8 +- .../lois_visco_elastiques/Loi_newton1D.cc | 4 +- .../lois_visco_elastiques/Loi_newton1D.h | 4 +- .../lois_visco_elastiques/Loi_newton2D_D.cc | 4 +- .../lois_visco_elastiques/Loi_newton2D_D.h | 4 +- .../lois_visco_elastiques/Loi_newton3D.cc | 4 +- .../lois_visco_elastiques/Loi_newton3D.h | 4 +- comportement/plasticite/Prandtl_Reuss.cc | 8 +- comportement/plasticite/Prandtl_Reuss.h | 8 +- comportement/plasticite/Prandtl_Reuss1D.cc | 8 +- comportement/plasticite/Prandtl_Reuss1D.h | 8 +- comportement/plasticite/Prandtl_Reuss2D_D.cc | 8 +- comportement/plasticite/Prandtl_Reuss2D_D.h | 8 +- comportement/thermique/Loi_de_Tait.cc | 10 +- comportement/thermique/Loi_de_Tait.h | 14 +- comportement/thermique/Loi_iso_thermo.cc | 12 +- comportement/thermique/Loi_iso_thermo.h | 14 +- .../Taux_crista/CristaliniteAbstraite.h | 14 +- .../thermique/Taux_crista/Hoffman1.cc | 12 +- comportement/thermique/Taux_crista/Hoffman1.h | 12 +- .../thermique/Taux_crista/Hoffman2.cc | 12 +- comportement/thermique/Taux_crista/Hoffman2.h | 12 +- contact/ElContact.cc | 4 +- contact/ElContact.h | 4 +- contact/LesContacts.cc | 2 +- contact/LesContacts.h | 6 +- contact/LesContacts_2.cc | 2 +- contact/LesContacts_3.cc | 2 +- tenseurs_mai99/Coordonnees/Coordonnee.cc | 2 +- tenseurs_mai99/Coordonnees/Coordonnee.h | 6 +- tenseurs_mai99/Coordonnees/Coordonnee1.cc | 2 +- tenseurs_mai99/Coordonnees/Coordonnee1.h | 6 +- tenseurs_mai99/Coordonnees/Coordonnee1B.cc | 2 +- tenseurs_mai99/Coordonnees/Coordonnee1H.cc | 4 +- tenseurs_mai99/Coordonnees/Coordonnee2.cc | 4 +- tenseurs_mai99/Coordonnees/Coordonnee2.h | 6 +- tenseurs_mai99/Coordonnees/Coordonnee2B.cc | 4 +- tenseurs_mai99/Coordonnees/Coordonnee2H.cc | 4 +- tenseurs_mai99/Coordonnees/Coordonnee3.cc | 4 +- tenseurs_mai99/Coordonnees/Coordonnee3.h | 6 +- tenseurs_mai99/Coordonnees/Coordonnee3B.cc | 4 +- tenseurs_mai99/Coordonnees/Coordonnee3H.cc | 4 +- tenseurs_mai99/Coordonnees/CoordonneeB.cc | 2 +- tenseurs_mai99/Coordonnees/CoordonneeH.cc | 2 +- tenseurs_mai99/Coordonnees/CoordonneeN.h | 2 +- 541 files changed, 3293 insertions(+), 2005 deletions(-) mode change 100755 => 100644 Elements/Mecanique/ElemMecaGene.h diff --git a/Algo/AlgoRef/Algori.cc b/Algo/AlgoRef/Algori.cc index e815649..0aba0fa 100644 --- a/Algo/AlgoRef/Algori.cc +++ b/Algo/AlgoRef/Algori.cc @@ -160,6 +160,7 @@ Algori::Algori () : // par defaut ,temps_transfert_court_charge(),temps_transfert_long_charge(),temps_attente_charge() ,temps_transfert_court_contact(),temps_transfert_long_contact(),temps_attente_contact() ,inter_transfer(),inter_transfer2() + ,buffer_ioBI_MPI(),tailles_buffer_ioBI_MPI() #endif //---------- stockage pour la transmission des grandeurs consultables ----- // ,stock_compteur(GENERIQUE_UNE_GRANDEUR_GLOBALE),val_stock_compteur(NULL) @@ -255,6 +256,7 @@ Algori::Algori (EnumTypeCalcul type,const bool avec_typeDeCal ,temps_transfert_court_charge(),temps_transfert_long_charge(),temps_attente_charge() ,temps_transfert_court_contact(),temps_transfert_long_contact(),temps_attente_contact() ,inter_transfer(),inter_transfer2() + ,buffer_ioBI_MPI(),tailles_buffer_ioBI_MPI() #endif //---------- stockage pour la transmission des grandeurs consultables ----- @@ -458,6 +460,7 @@ Algori::Algori (const Algori& algo) : ,temps_transfert_long_contact(algo.temps_transfert_long_contact) ,temps_attente_contact(algo.temps_attente_contact) ,inter_transfer(),inter_transfer2() + ,buffer_ioBI_MPI(algo.buffer_ioBI_MPI),tailles_buffer_ioBI_MPI(algo.tailles_buffer_ioBI_MPI) #endif //---------- stockage pour la transmission des grandeurs consultables ----- diff --git a/Algo/AlgoRef/Algori.h b/Algo/AlgoRef/Algori.h index d21c859..c1ec55b 100644 --- a/Algo/AlgoRef/Algori.h +++ b/Algo/AlgoRef/Algori.h @@ -83,6 +83,9 @@ #ifdef UTILISATION_MPI #include "Distribution_CPU.h" #include "ResRaid_MPI.h" + #include "mpi.h" + #include + namespace mpi = boost::mpi; #endif // peut-être à modifier sur linux @@ -331,7 +334,30 @@ class Algori DiversStockage* diversStockage,Charge* charge, LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats, int inc_voulu=0); - + #ifdef UTILISATION_MPI + // calcul des offsets pour la préparation à l'utilisation de MPI IO + // et transmission au proc i + void Calcul_offsets_IO_MPI + (int cas,LesMaillages *lesMaillages, + LesReferences* lesReferences,LesCourbes1D* lesCourbes1D, + LesFonctions_nD* lesFonctionsnD, + LesLoisDeComp* lesLoisDeComp, + DiversStockage* diversStockage,Charge* charge, + LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats, + OrdreVisu::EnumTypeIncre type_incre,int incre = 0); + // écriture des offsets MPI des infos bufferisées propres à Algo ref + void Ecriture_offset_et_buffersAlgoRef_base_info_MPI_IO(const int cas); + // Lecture des offsets MPI des infos bufferisées + void Lecture_offset_base_info_MPI_IO(const int cas); + + // préparation d'un flux sur buffer, pour algo dérivé + + // écriture MPI des infos bufferisées + void Ecriture_base_info_MPI_IO(const int cas); + + + #endif + // visualisation intéractive via le standard vrml // la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée // dans les algorithmes dérivées @@ -413,21 +439,22 @@ class Algori // si ptalgo est non nulle, on a une sortie des temps cpu, spécifique // à la classe AlgoriCombine passé en paramètre virtual void Ecriture_base_info - (ofstream& sort,const int cas); + (ostream& sort,const int cas); + // cas de la lecture spécifique à l'algorithme dans base_info - virtual void Lecture_base_info(ifstream& ent,const int cas); + virtual void Lecture_base_info(istream& ent,const int cas); // cas des paramètres spécifiques // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - virtual void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) = 0; + virtual void Ecrit_Base_info_Parametre(ostream& sort,const int& cas) = 0; // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - virtual void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) = 0; + virtual void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) = 0; // création d'un fichier de commande: cas des paramètres spécifiques virtual void Info_commande_parametres(UtilLecture& entreePrinc) = 0; @@ -449,12 +476,25 @@ class Algori // récupération de la position lue par l'algo dans le .BI, changé lors d'un restart par exemple // il s'agit de la sauvegarde par l'algo de la position qu'il a lue en restart + #ifndef UTILISATION_MPI streampos Debut_increment() const {return debut_increment;}; + #else + MPI_Offset Debut_increment() const {return debut_increment;}; + #endif + // ==============VARIABLES PROTEGEES : #ifdef UTILISATION_MPI // cas d'un calcul parallèle Distribution_CPU distribution_CPU_algo; // gestion de la distribution de charge sur CPU + // pour les i/o retardées + Tableau buffer_ioBI_MPI; // les buffers pour la sortie retardée + std::vector tailles_buffer_ioBI_MPI; // les tailles qui sont transmises par proc 0 + std::vector posi_tailles_buffer; // positions pour chaque classe principale + // 1 algo, 2 lesMaillages, 3 lesReferences, 4 lesCourbes1D, 5 lesFonctionsnD + // 6 lesLoisDeComp, 7 diversStockage, 8 charge, 9 lesCondlim, + // 10 lesContacts, 11 resultats + #endif // 1)----------- protégées: spécifiques à un algo ---------- @@ -483,8 +523,12 @@ class Algori Tableau noms_fichier; Tableau typeFlotExterne; UtilLecture* entreePrinc; // sauvegarde pour éviter les passages de paramètres - streampos debut_increment; // sanvegarde de la position du début d'incrément + #ifndef UTILISATION_MPI + streampos debut_increment; // sauvegarde de la position du début d'incrément suivant // lors d'un restart + #else + MPI_Offset debut_increment; + #endif Visualisation visualise; // instance sur les utilitaires de visualisation en vrml Visualisation_maple visualise_maple; // instance sur les utilitaires de visualisation en maple Visualisation_geomview visualise_geomview; // instance sur les utilitaires de visualisation en diff --git a/Algo/AlgoRef/Algori2.cc b/Algo/AlgoRef/Algori2.cc index f93b089..6d20067 100644 --- a/Algo/AlgoRef/Algori2.cc +++ b/Algo/AlgoRef/Algori2.cc @@ -58,8 +58,24 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages, { //il y a deux types d'entrée de donnée soit via un fichier info // soir via via base info int lec_ent_info = entreePrinc->Lec_ent_info(); - // récup du flot d'entrée + // récup du flot d'entrée + #ifndef UTILISATION_MPI ifstream * entrons = entreePrinc->Ent_BI(); + #else + int proc_en_cours = ParaGlob::Monde()->rank(); + // Lecture des offsets MPI des infos bufferisées + Algori::Lecture_offset_base_info_MPI_IO(cas); + + // a) ==== lecture du premier buffer propres à Algo ref et def du flux d'entrée associé + MPI_File * ent_MPI = entreePrinc->Ent_BI(); // récup du fichier + { char * buffer_car = new char [tailles_buffer_ioBI_MPI[0]] ; + MPI_Status status1; + int ierr1 = MPI_File_read_all(*ent_MPI, buffer_car, tailles_buffer_ioBI_MPI[0], MPI_CHAR, &status1); + // on crée le flux sur le tableau de caractères: + istrstream * entrons = new istrstream(buffer_car,tailles_buffer_ioBI_MPI[0]) ; + + #endif + // si l'incrément est positif on se positionne à l'incrément voulu if (inc_voulu >= 0) // lecture différenciée en fonction du cas -> positionnement à l'incrément donné @@ -135,10 +151,23 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages, } }; // fin du positionnement à l'incrément donné + #ifdef UTILISATION_MPI + }; // fin de la lecture du premier buffer + // b) ==== lecture du deuxième buffer propres à Algo ref et def du flux d'entrée associé + { char * buffer_car = new char [tailles_buffer_ioBI_MPI[1]] ; + MPI_Status status1; + int ierr1 = MPI_File_read_all(*ent_MPI, buffer_car, tailles_buffer_ioBI_MPI[1], MPI_CHAR, &status1); + // on crée le flux sur le tableau de caractères: + istrstream * entrons = new istrstream(buffer_car,tailles_buffer_ioBI_MPI[1]) ; + + #endif // lecture particulière à l'algorithme Lecture_base_info(*entrons,cas); #ifdef UTILISATION_MPI + }; // fin de la lecture du second buffer + ifstream * entrons = NULL; // en MPI on ne doit pas utiliser entrons, on le met donc à NULL + // ce qui permettra de détecter des erreurs éventuelles // si calcul on sauvegarde la distribution distribution_CPU_algo.Lecture_base_info(*entrons,cas); #endif @@ -153,9 +182,11 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages, lesContacts->Lec_base_info_LesContacts(*entrons,*lesMaillages , &LesMaillages::Noeud_LesMaille, &LesMaillages::Element_LesMaille); // lecture des contacts éventuelles resultats->Lect_result_base_info(*entrons,cas); // lecture des parametres de gestion de la sortie des resultats - // --- on récupère la position du pointeur dans le fichier + + // --- on récupère la position du pointeur dans le fichier, utilisé éventuellement ensuite pour l'écriture du prochain incrément // l'opération n'est pas si simple car on a deux cas: + #ifndef UTILISATION_MPI // 1) soit on est arrivée à la fin du fichier c-a-d eofbit = 1<<1, // -> 2 // dans ce cas il ne faut pas utiliser tellg() car cela va générer un failbit = 1<<2, // -> 4 // au contraire on va à la fin et ensuite on demande la position @@ -171,14 +202,15 @@ void Algori::Lecture_base_info(int cas,LesMaillages *lesMaillages, } else // sinon cela veut que l'on n'est pas à la fin, on peut donc récupérer la position debut_increment = entrons->tellg(); + #else + // cas MPI pour l'instant on considère que l'accès à la position est toujours ok (à confirmer !) + MPI_File_get_position(*ent_MPI,&debut_increment); + #endif + // mémorisation du temps de la sauvegarde temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant(); list_incre_temps_sauvegarder.push_front(Entier_et_Double(inc_voulu,temps_derniere_sauvegarde)); - - {// cas de la lecture de données déjà calculées - // a priori on effectue la lecture des maillages - // il faut penser au contact !!!!!!! - }; + }; // sauvegarde sur base info @@ -202,75 +234,116 @@ void Algori::Ecriture_base_info { tempsSauvegarde.Mise_en_route_du_comptage(); // temps cpu // récup des flots pour base info - ofstream * sortons = entreePrinc->Sort_BI(); bool sortie_effectuee = false; - switch (cas) - { case 1 : // ------- on sauvegarde tout ------------------------- - { entreePrinc->Enregistrement_position_increment_base_info(0.); - // écriture du numéro d'incrément = 0 pour signifier que c'est le début des infos - (*sortons) << "\n==========================================================================" - << "====================" - << "\n INCREMENT_DE_CHARGE_: " << 0 << " intensite " << 0. - << " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant() - << " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant() - << "\n=========================================================================================" - << "===================="; - // mémorisation du temps de la sauvegarde - temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant(); - list_incre_temps_sauvegarder.push_front(Entier_et_Double(0,temps_derniere_sauvegarde)); - sortie_effectuee = true; - break; - } - case 2 : // ----------- sauvegarde uniquement de se qui varie -------------------- - { // la sauvegarde est effectuée uniquement pour les incréments demandés - // --dans le cas où le temps courant == le dernier temps déjà sauvegardé, ce n'est pas la peine de faire une seconde sauvegarde - // sauf si c'est une demande explicite via les paramètres de contrôle - if ((pa.Variables_de_temps().TempsCourant() == temps_derniere_sauvegarde) - && (!pa.EtatSortieEtatActuelDansBI()))return; + #ifndef UTILISATION_MPI + ofstream * sortons = entreePrinc->Sort_BI(); + #else + int proc_en_cours = ParaGlob::Monde()->rank(); + // 1) dans le cas d'un proc 0 ou i, on redéfinit le flux de sortie, pour bufferiser les infos en sortie + // qui sont ensuite sortie via MPI i-o à l'aide de la méthode Ecriture_base_info_MPI_IO + // les récupérations et les sorties sont effectuées de manière asynchrone par rapport aux autres proc + // 2) seul le proc 0 sort l'entête et les paramètres spécifiques de l'algo - if ((pa.SauvegardeAutorisee(incre,temps_derniere_sauvegarde,(type_incre==OrdreVisu::DERNIER_INCRE))) // cas courant - || (pa.EtatSortieEtatActuelDansBI())) // cas où la demande est explicite -> ce n'est pas le cas courant - { - double temps = pa.Variables_de_temps().TempsCourant(); - entreePrinc->Enregistrement_position_increment_base_info(incre); - // écriture du numéro d'incrément dans le cas d'une sauvegarde partielle - // écriture du numéro d'incrément - (*sortons) << "\n=========================================================================================" - << "====================" - << "\n INCREMENT_DE_CHARGE_: " << incre << " intensite " - << setprecision(ParaGlob::NbdigdoCA()) << charge->IntensiteCharge() - << " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant() - << " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant() - << "\n=========================================================================================" - << "===================="; - // mémorisation du temps de la sauvegarde - temps_derniere_sauvegarde=temps; - list_incre_temps_sauvegarder.push_front(Entier_et_Double(incre,temps_derniere_sauvegarde)); - sortie_effectuee = true; - } - break; - } - default : - { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0)) - cout << "Algori::Ecriture_base_info(....)" - << " cas= " << cas << endl; - // dans le cas où un comptage du calcul est en cours on l'arrête - if (tempsSauvegarde.Comptage_en_cours()) tempsSauvegarde.Arret_du_comptage(); - if (tempsSortieFilCalcul.Comptage_en_cours()) tempsSortieFilCalcul.Arret_du_comptage(); - Sortie(1); - }; - }; - // écriture sur le flot de sortie en fonction du "cas" -// if ((incre % pa.Sauvegarde()) == 0) + if (proc_en_cours == 0) // première partie dédiée proc 0 + {// dimensionnement de buffer_ioBI_MPI + int taille_buffer_io_MPI = 2; // la partie entête + buffer_ioBI_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + std::ostringstream sort; // définition de sort + std::ostringstream * sortons = &sort; + #endif + switch (cas) + { case 1 : // ------- on sauvegarde tout ------------------------- + { entreePrinc->Enregistrement_position_increment_base_info(0.); + // écriture du numéro d'incrément = 0 pour signifier que c'est le début des infos + (*sortons) << "\n==========================================================================" + << "====================" + << "\n INCREMENT_DE_CHARGE_: " << 0 << " intensite " << 0. + << " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant() + << " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant() + << "\n=========================================================================================" + << "===================="; + // mémorisation du temps de la sauvegarde + temps_derniere_sauvegarde=pa.Variables_de_temps().TempsCourant(); + list_incre_temps_sauvegarder.push_front(Entier_et_Double(0,temps_derniere_sauvegarde)); + sortie_effectuee = true; + break; + } + case 2 : // ----------- sauvegarde uniquement de se qui varie -------------------- + { // la sauvegarde est effectuée uniquement pour les incréments demandés + // --dans le cas où le temps courant == le dernier temps déjà sauvegardé, ce n'est pas la peine de faire une seconde sauvegarde + // sauf si c'est une demande explicite via les paramètres de contrôle + if ((pa.Variables_de_temps().TempsCourant() == temps_derniere_sauvegarde) + && (!pa.EtatSortieEtatActuelDansBI()))return; + + if ((pa.SauvegardeAutorisee(incre,temps_derniere_sauvegarde,(type_incre==OrdreVisu::DERNIER_INCRE))) // cas courant + || (pa.EtatSortieEtatActuelDansBI())) // cas où la demande est explicite -> ce n'est pas le cas courant + { + double temps = pa.Variables_de_temps().TempsCourant(); + entreePrinc->Enregistrement_position_increment_base_info(incre); + // écriture du numéro d'incrément dans le cas d'une sauvegarde partielle + // écriture du numéro d'incrément + (*sortons) << "\n=========================================================================================" + << "====================" + << "\n INCREMENT_DE_CHARGE_: " << incre << " intensite " + << setprecision(ParaGlob::NbdigdoCA()) << charge->IntensiteCharge() + << " t= " << setprecision(ParaGlob::NbdigdoCA()) << pa.Variables_de_temps().TempsCourant() + << " dt= " << setprecision(ParaGlob::NbdigdoCA())<< ParaGlob::Variables_de_temps().IncreTempsCourant() + << "\n=========================================================================================" + << "===================="; + // mémorisation du temps de la sauvegarde + temps_derniere_sauvegarde=temps; + list_incre_temps_sauvegarder.push_front(Entier_et_Double(incre,temps_derniere_sauvegarde)); + sortie_effectuee = true; + } + break; + } + default : + { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; + if ( ((permet_affichage==0) && (ParaGlob::NiveauImpression() > 0)) || (permet_affichage > 0)) + cout << "Algori::Ecriture_base_info(....)" + << " cas= " << cas << endl; + // dans le cas où un comptage du calcul est en cours on l'arrête + if (tempsSauvegarde.Comptage_en_cours()) tempsSauvegarde.Arret_du_comptage(); + if (tempsSortieFilCalcul.Comptage_en_cours()) tempsSortieFilCalcul.Arret_du_comptage(); + Sortie(1); + }; + }; + #ifdef UTILISATION_MPI + buffer_ioBI_MPI(1) = sort.str(); // on sauvegarde + }; // fin de la sortie de l'entête proc 0 + #endif + + // écriture sur le flot de sortie en fonction du "cas" if (sortie_effectuee) { - // ******* reste lescontacts - Ecriture_base_info(*sortons,cas); #ifdef UTILISATION_MPI + if (proc_en_cours == 0) // deuxième partie dédiée proc 0 + {// redéfinition de sortons sur un nouveau buffer de charactère + std::ostringstream sort; // définition de sort + std::ostringstream * sortons = &sort; + #endif + Ecriture_base_info(*sortons,cas); + #ifdef UTILISATION_MPI + buffer_ioBI_MPI(2) = sort.str(); // on sauvegarde + }; // fin du cas proc 0 + // on redéfinit sortons pointant sur un buffer qui doit rester vide + // car en MPI il ne faut pas l'utiliser directement ici + +// ********** arrêt transitoire pour tester la technique de sauvegarde et lecture **** +cout << "\n ********** arrêt transitoire pour tester la technique de sauvegarde et lecture **** " + << "\n Algori::Ecriture_base_info " << endl; +Sortie(1); + + + + + + std::ostringstream sort; // définition de sort + std::ostringstream * sortons = &sort; // si calcul on sauvegarde la distribution distribution_CPU_algo.Ecriture_base_info(*sortons,cas); #endif + lesMaillages->Ecriture_base_info(*sortons,cas); // Ecriture des maillages et des references lesReferences->Ecriture_base_info(*sortons,cas); // Ecriture des references lesCourbes1D->Ecriture_base_info(*sortons,cas); // Ecriture des courbes1D @@ -281,12 +354,197 @@ void Algori::Ecriture_base_info lesCondlim->Ecriture_base_info(*sortons,cas); // Ecriture des ddl bloques lesContacts->Ecri_base_info_LesContacts(*sortons); // Ecriture des contacts éventuelles resultats->Ecri_result_base_info(*sortons,cas); // Ecriture des parametres de gestion de la sortie des resultats - (*sortons) << "\n\n" << endl; // pour passer une ligne et avoir une séparation plus claireflush; + + #ifdef UTILISATION_MPI + #ifdef MISE_AU_POINT + // normalement le buffer doit-être vide ! on vérifie + string toto(sort.str()); + if (toto.size()) + {cout << "\n *** sans doute une erreur, le buffer toto devrait etre vide !! " + << "\n Algori::Ecriture_base_info(..." + << "\n toto = " << toto << endl; + Sortie(1); + }; + #endif + + // si MPI on calcul les offsets pour l'écriture réelle en MPI IO + Calcul_offsets_IO_MPI(cas,lesMaillages,lesReferences,lesCourbes1D + ,lesFonctionsnD,lesLoisDeComp,diversStockage + ,charge,lesCondlim,lesContacts,resultats + ,type_incre,incre); + // on écrit les offsets et des buffers propres à Algo ref + Ecriture_offset_et_buffersAlgoRef_base_info_MPI_IO(cas); + // on sort sur fichier les buffer + Ecriture_base_info_MPI_IO(cas); + + #endif + // cout << "\n écriture terminée !!"; }; tempsSauvegarde.Arret_du_comptage(); // temps cpu }; +#ifdef UTILISATION_MPI + // calcul des offsets pour la préparation à l'utilisation de MPI IO + // et transmission au proc i + void Algori::Calcul_offsets_IO_MPI + (int cas,LesMaillages *lesMaillages, + LesReferences* lesReferences,LesCourbes1D* lesCourbes1D, + LesFonctions_nD* lesFonctionsnD, + LesLoisDeComp* lesLoisDeComp, + DiversStockage* diversStockage,Charge* charge, + LesCondLim* lesCondlim,LesContacts* lesContacts,Resultats* resultats, + OrdreVisu::EnumTypeIncre type_incre,int incre) + { // concernant l'algo de ref + tailles_buffer_ioBI_MPI[0] = buffer_ioBI_MPI(1).size(); + tailles_buffer_ioBI_MPI[1] = buffer_ioBI_MPI(2).size(); + + + + +// Tableau buffer_ioBI_MPI; // les buffers pour la sortie retardée +// std::vector tailles_buffer_ioBI_MPI; // les tailles qui sont transmises par proc 0 +// std::vector posi_tailles_buffer; // positions pour chaque classe principale +// // 1 algo, 2 lesMaillages, 3 lesReferences, 4 lesCourbes1D, 5 lesFonctionsnD +// // 6 lesLoisDeComp, 7 diversStockage, 8 charge, 9 lesCondlim, +// // 10 lesContacts, 11 resultats + + + }; + +// écriture des offsets MPI des infos bufferisées +void Algori::Ecriture_offset_et_buffersAlgoRef_base_info_MPI_IO(const int cas) + { int proc_en_cours = ParaGlob::Monde()->rank(); + // concerne uniquement le proc 0 + union entier_caractere // par simplicité + { int n ; char ch[4]; }; + if (proc_en_cours == 0) + { MPI_File * sort_MPI = entreePrinc->Sort_BI(); // récup du fichier + // === écriture dans flot string de la taille des buffers propres à algo ref + // et de la taille du vector posi_tailles_buffer + // pour avoir une sortie lisible, on crée tout d'abord un buffer string avec les infos + std::ostringstream buf2(std::ios_base::out); + buf2 << "\n offset_base_info_MPI_IO \n"; + int taille_tailles_buffer_ioBI_MPI = tailles_buffer_ioBI_MPI.size(); // c'est 2 + for (int i=0;i < taille_tailles_buffer_ioBI_MPI;i++) + buf2 << tailles_buffer_ioBI_MPI[i] << " "; + // puis la taille de posi_tailles_buffer + int taille_posi_tailles_buffer = posi_tailles_buffer.size(); + buf2 << "\n posi_tailles_buffer \n"; + buf2 << taille_posi_tailles_buffer << " "; + // puis posi_tailles_buffer + for (int i=0; i < taille_posi_tailles_buffer ; i++) + buf2 << posi_tailles_buffer[i] << " "; + + // le buffer du stream n'est pas pérenne il faut le récupérer + string buf_inter = buf2.str(); // on récupère le buffer + int taille_buf = buf_inter.size(); + + // 1) ==== écriture de la taille de l'ensemble des offsets propres à Algo ref + // on encapsule pour ré-utiliser la même trame + { + entier_caractere i_c; + i_c.n = taille_buf; + string deb("tout_offset "); + deb.insert(12,*(i_c.ch),4); // ce qui fait 16 caractères qu'on lira avant tout chose + // sortie sur fichier de la taille de buf2 + MPI_Status *status; // pour le retour + int ierr = MPI_File_write(*sort_MPI,deb.c_str(),16,MPI_CHAR,status); + }; + + // 2) ==== écriture de la taille des buffers propres à Algo ref + // et de la taille de posi_tailles_buffer et de posi_tailles_buffer lui-même + { // sortie sur fichier de buf2 + MPI_Status *status; // pour le retour + int ierr = MPI_File_write(*sort_MPI,buf_inter.c_str(),taille_buf,MPI_CHAR,status); + }; + + // 3) ==== écriture des buffers propres à Algo ref + { MPI_Status *status; // pour le retour + for (int i=1;i<= 2;i++) + {int ierr = MPI_File_write(*sort_MPI,buffer_ioBI_MPI(i).c_str() + ,buffer_ioBI_MPI(i).size(),MPI_CHAR,status); + }; + }; + }; + }; + +// Lecture des offsets MPI des infos bufferisées +void Algori::Lecture_offset_base_info_MPI_IO(const int cas) + {// on commence par lire la taille du buffer d'offset + MPI_File * ent_MPI = entreePrinc->Ent_BI(); // récup du fichier + // tous les proc lisent + + // 1) ==== la taille de l'ensemble des offsets propres à Algo ref + int taille_buf = 0; // init + // on encapsule pour ré-utiliser la même trame + { char * buffer_car = new char [16] ; // def du tableau de travail + MPI_Status status; + int ierr = MPI_File_read_all(*ent_MPI, buffer_car, 16, MPI_CHAR, &status); + // on crée un flux sur le tableau de caractères: + istrstream * ent_inter = new istrstream(buffer_car,16) ; + // lecture de l'entête + string toto; + (*ent_inter) >> toto; + if (toto != "tout_offset" ) + {cout << "\n **** erreur on devait lire : 'tout_offset' " + << " et on lue "<< toto << " la suite n'est pas possible -> arret !! " + << "\n Algori::Lecture_offset_base_info_MPI_IO(... "<> toto >> taille_buf; + }; + // 2) ==== lecture de la taille des buffers propres à Algo ref + // et de la taille de posi_tailles_buffer et de posi_tailles_buffer lui-même + { char * buffer_car = new char [taille_buf] ; // def du tableau de travail + MPI_Status status; + int ierr = MPI_File_read_all(*ent_MPI, buffer_car, taille_buf, MPI_CHAR, &status); + // on crée un flux sur le tableau de caractères: + istrstream * ent_inter = new istrstream(buffer_car,taille_buf) ; + // lecture de l'entête + string toto; + (*ent_inter) >> toto; + if (toto != "offset_base_info_MPI_IO" ) + {cout << "\n **** erreur on devait lire : 'offset_base_info_MPI_IO' " + << " et on lue "<< toto << " la suite n'est pas possible -> arret !! " + << "\n Algori::Lecture_offset_base_info_MPI_IO(... "<> tailles_buffer_ioBI_MPI[i]; + // puis la taille de posi_tailles_buffer + int taille_posi_tailles_buffer = 0; + (*ent_inter) >> toto; + if (toto != "posi_tailles_buffer" ) + {cout << "\n **** erreur on devait lire : 'posi_tailles_buffer' " + << " et on lue "<< toto << " la suite n'est pas possible -> arret !! " + << "\n Algori::Lecture_base_info(... "<> taille_posi_tailles_buffer; + posi_tailles_buffer.resize(taille_posi_tailles_buffer); + // puis lecture de posi_tailles_buffer + for (int i=0; i < taille_posi_tailles_buffer ; i++) + (*ent_inter) >> posi_tailles_buffer[i]; + }; + + }; + +// écriture MPI des infos bufferisées +void Algori::Ecriture_base_info_MPI_IO(const int cas) + { + + }; + + + +#endif // fin MPI + + + // visualisation intéractive via le standard vrml // la fonction est virtuelle ce qui lui permet d'être éventuellement facilement surchargée // dans les algorithmes dérivées @@ -1803,7 +2061,7 @@ void Algori::VisuAuFilDuCalcul(ParaGlob * paraGlob,LesMaillages * lesMaillages,L // éventuellement est définit de manière spécifique pour chaque algorithme // dans les classes filles void Algori::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort, int cas) {switch (cas) { case 1 : // on sauvegarde tout { @@ -1815,7 +2073,7 @@ void Algori::Ecriture_base_info //sort << "\n debug algori::ecriture_base_info " // << "\n -----parametre_et_variables_particulieres_algo: Nom_TypeCalcul(typeCalcul)= "<< Nom_TypeCalcul(typeCalcul) // << flush; - Ecrit_Base_info_Parametre(*entreePrinc,cas); + Ecrit_Base_info_Parametre(sort,cas); sort << "\n -----FIN_parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul); sort << "\n mode_debug= " << mode_debug << " "; //--- amortissement cinétique @@ -1931,7 +2189,7 @@ void Algori::Ecriture_base_info // ----- écriture éventuelle des paramètres de l'algorithme et informations particulières sort << "\n -----parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul); - Ecrit_Base_info_Parametre(*entreePrinc,cas); + Ecrit_Base_info_Parametre(sort,cas); sort << " \n -----FIN_parametre_et_variables_particulieres_algo: " << Nom_TypeCalcul(typeCalcul) ; //------- modulation de la précision d'équilibre --- if (modulation_precision != NULL) @@ -1980,7 +2238,7 @@ void Algori::Ecriture_base_info // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Algori::Lecture_base_info(ifstream& ent,const int cas) +void Algori::Lecture_base_info(istream& ent,int cas) { switch (cas) { case 1 : // on récupère tout { // ----- lecture éventuelle des paramètres de l'algorithme @@ -1992,7 +2250,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas) ent >> nom2; if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul) { // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer - Lecture_Base_info_Parametre(*entreePrinc,cas,true); + Lecture_Base_info_Parametre(ent,cas,true); // on finit la lecture en passant les dernières lignes jusqu'au mot clé ent >> nom1; while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:") @@ -2005,7 +2263,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas) ent >> nom1; ent >> nom1; // enfin on passe le nom de l'algo // on demande à l'agorithme de faire une initialisation sans lecture - Lecture_Base_info_Parametre(*entreePrinc,cas,false); + Lecture_Base_info_Parametre(ent,cas,false); }; } else @@ -2139,7 +2397,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas) ent >> nom2; if (Id_nom_TypeCalcul(nom2.c_str()) == typeCalcul) { // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer - Lecture_Base_info_Parametre(*entreePrinc,cas,true); + Lecture_Base_info_Parametre(ent,cas,true); // on finit la lecture en passant les dernières lignes jusqu'au mot clé ent >> nom1; while (nom1 != "-----FIN_parametre_et_variables_particulieres_algo:") @@ -2152,7 +2410,7 @@ void Algori::Lecture_base_info(ifstream& ent,const int cas) ent >> nom1; ent >> nom1; // enfin on passe le nom de l'algo // on demande à l'agorithme de faire une initialisation sans lecture - Lecture_Base_info_Parametre(*entreePrinc,cas,false); + Lecture_Base_info_Parametre(ent,cas,false); }; } else diff --git a/Algo/AlgoUtilitaires/AlgoInformations.h b/Algo/AlgoUtilitaires/AlgoInformations.h index 031c8f3..fce9dfc 100644 --- a/Algo/AlgoUtilitaires/AlgoInformations.h +++ b/Algo/AlgoUtilitaires/AlgoInformations.h @@ -151,12 +151,12 @@ class AlgoInformations : public Algori // METHODES PROTEGEES : // --- venant du virtuel --- // écriture des paramètres dans la base info (ici rien) - void Ecrit_Base_info_Parametre(UtilLecture& ,const int& ) {}; + void Ecrit_Base_info_Parametre(ostream& ,const int& ) {}; // lecture des paramètres dans la base info (ici rien) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& ,const int& ,bool ) {}; + void Lecture_Base_info_Parametre(istream& ,const int& ,bool ) {}; // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& ) {Algori::Info_com_parametres(*entreePrinc);}; }; diff --git a/Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc b/Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc index 228d8a7..c4b8887 100644 --- a/Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc +++ b/Algo/AlgoUtilitaires/AlgoUmatAbaqus.cc @@ -425,14 +425,14 @@ void AlgoUmatAbaqus::Calcul_Umat(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info (cas,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage ,charge,lesCondLim,lesContacts,resultats,OrdreVisu::INCRE_0); // visualisation éventuelle au fil du calcul - VisuAuFilDuCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage,charge + VisuAuFilDuCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage,charge ,lesCondLim,lesContacts,resultats,type_incre,(*(inne->incre)-1)); }; }; @@ -519,7 +519,7 @@ void AlgoUmatAbaqus::Calcul_Umat(ParaGlob * paraGlob,LesMaillages * lesMail, // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) -void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { // récup du flot // ofstream * sort = entreePrinc.Sort_BI(); @@ -537,7 +537,7 @@ void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const in // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoUmatAbaqus::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) +void AlgoUmatAbaqus::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) {if (cas == 1) {if (choix) {// cas d'une lecture normale diff --git a/Algo/AlgoUtilitaires/AlgoUmatAbaqus.h b/Algo/AlgoUtilitaires/AlgoUmatAbaqus.h index c83911f..1d07b27 100644 --- a/Algo/AlgoUtilitaires/AlgoUmatAbaqus.h +++ b/Algo/AlgoUtilitaires/AlgoUmatAbaqus.h @@ -159,14 +159,14 @@ class AlgoUmatAbaqus : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Algo/AlgoUtilitaires/AlgoUtils.h b/Algo/AlgoUtilitaires/AlgoUtils.h index d32fff9..2d1a98d 100644 --- a/Algo/AlgoUtilitaires/AlgoUtils.h +++ b/Algo/AlgoUtilitaires/AlgoUtils.h @@ -154,12 +154,12 @@ class AlgoUtils : public Algori // METHODES PROTEGEES : // --- venant du virtuel --- // écriture des paramètres dans la base info (ici rien) - void Ecrit_Base_info_Parametre(UtilLecture& ,const int& ) {}; + void Ecrit_Base_info_Parametre(ostream& ,const int& ) {}; // lecture des paramètres dans la base info (ici rien) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& ,const int& ,bool) {}; + void Lecture_Base_info_Parametre(istream& ,const int& ,bool) {}; // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& ) {Algori::Info_com_parametres(*entreePrinc);}; }; diff --git a/Algo/AlgorithmeCombiner/AlgoriCombine.cc b/Algo/AlgorithmeCombiner/AlgoriCombine.cc index 08d3c28..86c4239 100755 --- a/Algo/AlgorithmeCombiner/AlgoriCombine.cc +++ b/Algo/AlgorithmeCombiner/AlgoriCombine.cc @@ -421,9 +421,8 @@ void AlgoriCombine::Creation_fct_cst() // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrit uniquement les données variables (supposées comme telles) -void AlgoriCombine::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void AlgoriCombine::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { - ofstream& sort = *entreePrinc.Sort_BI(); if (cas == 1) {//-- tout d'abord les fonctions de gestion d'algo // choix des sous_algo @@ -446,7 +445,7 @@ void AlgoriCombine::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int int nb_algo = tab_algo.Taille(); for (int i=1;i<=nb_algo;i++) { sort << "\n ----->>parametres_sous_algo_specifiques_ "<< Nom_TypeCalcul(tab_algo(i)->TypeDeCalcul()); - tab_algo(i)->Ecrit_Base_info_Parametre(entreePrinc,cas); + tab_algo(i)->Ecrit_Base_info_Parametre(sort,cas); sort << "\n ----->>fin_parametres_sous_algo_specifiques_ "<< Nom_TypeCalcul(tab_algo(i)->TypeDeCalcul()); }; }; @@ -458,32 +457,29 @@ void AlgoriCombine::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoriCombine::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) +void AlgoriCombine::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) { - // récup du flot - ifstream * ent = entreePrinc.Ent_BI(); if (cas == 1) {// dimensionnement if (choix) {// cas d'une lecture normale - ifstream * ent = entreePrinc.Ent_BI(); string toto; - (*ent) >> toto; // on passe l'entête + ent >> toto; // on passe l'entête //-- tout d'abord les fonctions de gestion d'algo // choix des sous_algo - (*ent) >> toto; // on passe l'entête + ent >> toto; // on passe l'entête if (toto == "aucune") {nom_choix_algo = "";choix_algo=NULL;} else {nom_choix_algo = toto;}; // gestion de sauvegarde - (*ent) >> toto; // on passe l'entête + ent >> toto; // on passe l'entête if (toto == "aucune") {nom_gestion_sauvegarde = "";gestion_sauvegarde=NULL;} else {nom_gestion_sauvegarde = toto;}; // gestion de sortie à convergence - (*ent) >> toto; // on passe l'entête + ent >> toto; // on passe l'entête if (toto == "aucune") {nom_gestion_sortie_a_convergence = "";gestion_sortie_a_convergence=NULL;} else @@ -496,26 +492,26 @@ void AlgoriCombine::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const i // de sous-algo donc il y a une première ligne qui indique de quel sous algo il s'agit // on suit la même logique que celle de Algori::Ecriture_base_info string nom1,nom2; - (*ent) >> nom1 ; + ent >> nom1 ; if (nom1 == "----->>parametres_sous_algo_specifiques_") { // lecture du nom de l'algo - (*ent) >> nom2; + ent >> nom2; if (Id_nom_TypeCalcul(nom2.c_str()) == tab_algo(i)->TypeDeCalcul()) { // les données sauvegardées correspondent à l'algo en cours, on peut les récupérer - Lecture_Base_info_Parametre(entreePrinc,cas,true); + Lecture_Base_info_Parametre(ent,cas,true); // on finit la lecture en passant les dernières lignes jusqu'au mot clé - (*ent) >> nom1; + ent >> nom1; while (nom1 != "----->>fin_parametres_sous_algo_specifiques_") - (*ent) >> nom1; - (*ent) >> nom1; // enfin on passe le nom de l'algo + ent >> nom1; + ent >> nom1; // enfin on passe le nom de l'algo } else { // l'algo ne correspond pas, on passe les informations correspondants while (nom1 != "----->>fin_parametres_sous_algo_specifiques_:") - (*ent) >> nom1; - (*ent) >> nom1; // enfin on passe le nom de l'algo + ent >> nom1; + ent >> nom1; // enfin on passe le nom de l'algo // on demande à l'agorithme de faire une initialisation sans lecture - Lecture_Base_info_Parametre(entreePrinc,cas,false); + Lecture_Base_info_Parametre(ent,cas,false); }; } else @@ -530,7 +526,7 @@ void AlgoriCombine::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const i Sortie(1); }; - tab_algo(i)->Lecture_Base_info_Parametre(entreePrinc,cas,choix); + tab_algo(i)->Lecture_Base_info_Parametre(ent,cas,choix); } } }; @@ -891,7 +887,7 @@ void AlgoriCombine::Lecture_algo_interne(const bool avec_typeDeCal // sortie des temps cpu cumulées de tous les algos -void AlgoriCombine::AutreSortieTempsCPU(ofstream& sort,const int ) const +void AlgoriCombine::AutreSortieTempsCPU(ostream& sort,const int ) const { // on commence par cumuler tous les temps de calcul Tableau lesTsCpu(18); // init diff --git a/Algo/AlgorithmeCombiner/AlgoriCombine.h b/Algo/AlgorithmeCombiner/AlgoriCombine.h index 2761603..53b5574 100755 --- a/Algo/AlgorithmeCombiner/AlgoriCombine.h +++ b/Algo/AlgorithmeCombiner/AlgoriCombine.h @@ -151,7 +151,7 @@ class AlgoriCombine : public Algori void SchemaXML_Algori(ofstream& ,const Enum_IO_XML ) const ; // sortie des temps cpu cumulées de tous les algos - void AutreSortieTempsCPU(ofstream& sort,const int cas) const; + void AutreSortieTempsCPU(ostream& sort, int cas) const; // sortie pour info de la liste des énumérés de tous les sous-algo list List_Sous_Algo() const; @@ -209,9 +209,9 @@ class AlgoriCombine : public Algori // // éventuellement est définit de manière spécifique pour chaque algorithme // // dans les classes filles // virtual void Ecriture_base_info -// (ofstream& sort,const int cas); +// (ofstream& sort, int cas); // // cas de la lecture spécifique à l'algorithme dans base_info -// virtual void Lecture_base_info(ifstream& ent,const int cas); +// virtual void Lecture_base_info(ifstream& ent,int cas); // lecture des paramètres du calcul void lecture_Parametres(UtilLecture& entreePrinc); @@ -221,14 +221,14 @@ class AlgoriCombine : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Algo/AlgorithmeCombiner/AlgoriCombine2.cc b/Algo/AlgorithmeCombiner/AlgoriCombine2.cc index 0e6dfea..2858903 100755 --- a/Algo/AlgorithmeCombiner/AlgoriCombine2.cc +++ b/Algo/AlgorithmeCombiner/AlgoriCombine2.cc @@ -158,7 +158,7 @@ void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -168,8 +168,8 @@ void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; }; tempsInitialisation.Arret_du_comptage(); // temps cpu diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc index 514127f..58f6437 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.cc @@ -262,11 +262,8 @@ void AlgoriRungeKutta::Execution(ParaGlob * paraGlob,LesMaillages * lesMail // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) -void AlgoriRungeKutta::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) -{ // récup du flot - ofstream& sort = *entreePrinc.Sort_BI(); -// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); - switch (cas) +void AlgoriRungeKutta::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) +{ switch (cas) {case 1 : // ------- on sauvegarde tout ------------------------- { // ecriture des parametres de réglage du pilotage de RK @@ -281,7 +278,7 @@ void AlgoriRungeKutta::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoriRungeKutta::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoriRungeKutta::Ecrit_Base_info_Parametre(ostream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } @@ -295,10 +292,8 @@ void AlgoriRungeKutta::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const // choix = true : fonctionememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoriRungeKutta::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) -{// récup du flot - ifstream& ent = *entreePrinc.Ent_BI(); - string toto; +void AlgoriRungeKutta::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) +{string toto; if (choix) {switch (cas) {case 1 : // ------- on récupère tout ------------------------- @@ -313,7 +308,7 @@ void AlgoriRungeKutta::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,cons } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoriRungeKutta::Lecture_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoriRungeKutta::Lecture_Base_info_Parametre(istream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } @@ -1171,7 +1166,7 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -1181,9 +1176,9 @@ void AlgoriRungeKutta::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; + } //--fin cas de restart et/ou de sauvegarde-------- // ajout d'un conteneur pour les coordonnées à l'itération 0 diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h index 4cc6202..397fdc1 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoRungeKutta.h @@ -210,14 +210,14 @@ class AlgoriRungeKutta : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc index 825ab5e..7a5a8d0 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.cc @@ -462,7 +462,7 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -472,8 +472,8 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- @@ -923,10 +923,8 @@ void AlgoriDynaExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) -void AlgoriDynaExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) -{ // récup du flot - ofstream& sort = *entreePrinc.Sort_BI(); -// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); +void AlgoriDynaExpli::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) +{ // sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); switch (cas) {case 1 : // ------- on sauvegarde tout ------------------------- { @@ -946,7 +944,7 @@ void AlgoriDynaExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoriDynaExpli::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoriDynaExpli::Ecrit_Base_info_Parametre(ostream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } @@ -960,10 +958,8 @@ void AlgoriDynaExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i // choix = true : fonctionememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoriDynaExpli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) -{// récup du flot - ifstream& ent = *entreePrinc.Ent_BI(); - string toto; +void AlgoriDynaExpli::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) +{string toto; if (choix) {switch (cas) {case 1 : // ------- on récupère tout ------------------------- @@ -987,7 +983,7 @@ void AlgoriDynaExpli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoriDynaExpli::Lecture_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoriDynaExpli::Lecture_Base_info_Parametre(istream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h index 8808772..4c104ba 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli.h @@ -213,14 +213,14 @@ class AlgoriDynaExpli : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc index d6f10c0..4449664 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli2.cc @@ -219,9 +219,9 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; - paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); + paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info (cas,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage ,charge,lesCondLim,lesContacts,resultats,OrdreVisu::INCRE_0); @@ -229,8 +229,8 @@ void AlgoriDynaExpli::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMa else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- @@ -1011,7 +1011,7 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -1021,8 +1021,8 @@ void AlgoriDynaExpli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; }; //--fin cas de restart et/ou de sauvegarde-------- diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.cc index e1ff6bd..ce98c7b 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.cc @@ -501,7 +501,7 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -511,8 +511,8 @@ void AlgoriDynaExpli_zhai::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * les else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; }; //--fin cas de restart et/ou de sauvegarde-------- @@ -1269,7 +1269,7 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -1279,8 +1279,8 @@ void AlgoriDynaExpli_zhai::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * l else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- @@ -1743,15 +1743,12 @@ void AlgoriDynaExpli_zhai::lecture_Parametres(UtilLecture& entreePrinc) // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) -void AlgoriDynaExpli_zhai::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void AlgoriDynaExpli_zhai::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { - // récup du flot - ofstream * sort = entreePrinc.Sort_BI(); -// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); if (cas == 1) { - // ecriture du parametre - *(sort) << "phi_minus= " << paraTypeCalcul(1) << " " + // ecriture du parametre + sort << "phi_minus= " << paraTypeCalcul(1) << " " << "grand_phi=" << paraTypeCalcul(2)<< " " << "gamma=" << paraTypeCalcul(3)<< " " << "beta=" << paraTypeCalcul(4); @@ -1766,33 +1763,30 @@ void AlgoriDynaExpli_zhai::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,co // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) +void AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) {if (cas == 1) { // dimensionnement paraTypeCalcul.Change_taille(4); if(choix) - {// cas d'une lecture normale - // récup du flot - ifstream * ent = entreePrinc.Ent_BI(); - string toto; + {string toto; // lecture du parametre - *(ent) >> toto ; + ent >> toto ; if (toto != "phi_minus=") { cout << "\n erreur en lecture du parametre de l'algorithme explicite " << "\n on attendait le mot : phi_minus= , au lieu de " << toto << "\n AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> paraTypeCalcul(1) ; - *(ent) >> toto ; + ent >> paraTypeCalcul(1) ; + ent >> toto ; if (toto != "grand_phi=") { cout << "\n erreur en lecture du parametre de l'algorithme explicite " << "\n on attendait le mot : grand_phi , au lieu de " << toto << "\n AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> paraTypeCalcul(2) ; - *(ent) >> toto ; + ent >> paraTypeCalcul(2) ; + ent >> toto ; if (toto != "gamma=") { cout << "\n erreur en lecture du parametre de l'algorithme explicite " << "\n on attendait le mot : gamma= , au lieu de " << toto @@ -1800,8 +1794,8 @@ void AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre(UtilLecture& entreePrinc, Sortie(1); }; // lecture du parametre - *(ent) >> paraTypeCalcul(3); - *(ent) >> toto ; + ent >> paraTypeCalcul(3); + ent >> toto ; if (toto != "beta=") { cout << "\n erreur en lecture du parametre de l'algorithme explicite " << "\n on attendait le mot : beta= , au lieu de " << toto @@ -1809,7 +1803,7 @@ void AlgoriDynaExpli_zhai::Lecture_Base_info_Parametre(UtilLecture& entreePrinc, Sortie(1); }; // lecture du parametre - *(ent) >> paraTypeCalcul(4); + ent >> paraTypeCalcul(4); } else { // cas où la lecture est impossible, on attribut les valeurs par défaut diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.h b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.h index b5560e6..d4e41e9 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.h +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/AlgoriDynaExpli_zhai.h @@ -209,12 +209,12 @@ class AlgoriDynaExpli_zhai : public Algori // lecture des paramètres du calcul void lecture_Parametres(UtilLecture& entreePrinc); // écriture des paramètres dans la base info - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); // gestion et vérification du pas de temps et modif en conséquence si nécessaire diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc index 46c1b31..dc412cb 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.cc @@ -495,7 +495,7 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -505,8 +505,8 @@ void Algori_chung_lee::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; }; //--fin cas de restart et/ou de sauvegarde-------- @@ -1269,7 +1269,7 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -1279,8 +1279,8 @@ void Algori_chung_lee::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- @@ -1788,14 +1788,12 @@ void Algori_chung_lee::lecture_Parametres(UtilLecture& entreePrinc) // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) -void Algori_chung_lee::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void Algori_chung_lee::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { - // récup du flot - ofstream * sort = entreePrinc.Sort_BI(); // ecriture du parametre // (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); if (cas == 1) - { *(sort) << "beta= " << paraTypeCalcul(1) << " "; + { sort << "beta= " << paraTypeCalcul(1) << " "; } // (*sort) << "\n fin_parametres_algo_specifiques_ "; }; @@ -1806,24 +1804,23 @@ void Algori_chung_lee::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void Algori_chung_lee::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) +void Algori_chung_lee::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) {if (cas == 1) {// dimensionnement paraTypeCalcul.Change_taille(1); if (choix) {// cas d'une lecture normale // récup du flot - ifstream * ent = entreePrinc.Ent_BI(); string toto; // lecture du parametre - *(ent) >> toto ; + ent >> toto ; if (toto != "beta=") { cout << "\n erreur en lecture du parametre de l'algorithme explicite " << "\n on attendait le mot : beta= , au lieu de " << toto << "\n Algori_chung_lee::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> paraTypeCalcul(1) ; + ent >> paraTypeCalcul(1) ; } else {// cas où la lecture n'est pas possible, attribution des valeurs par défaut diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h index eb28dc4..f0fc13a 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_chung_lee.h @@ -210,14 +210,14 @@ class Algori_chung_lee : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); // gestion et vérification du pas de temps et modif en conséquence si nécessaire diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc index 5509b50..50988e8 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.cc @@ -348,9 +348,8 @@ void AlgoriRelaxDyna::Execution(ParaGlob * paraGlob,LesMaillages * lesMail // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) -void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { // récup du flot - ofstream& sort = *entreePrinc.Sort_BI(); // sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); switch (cas) {case 1 : // ------- on sauvegarde tout ------------------------- @@ -393,7 +392,7 @@ void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i {sort << "\n ponderationGrandeurGlobale_lambda 0 ";} else {sort << "\n ponderationGrandeurGlobale_lambda 1 " ; - niveauLambda_grandeurGlobale->Ecriture_base_info(sort,cas,sans_courbe); + niveauLambda_grandeurGlobale->Ecriture_base_info(sort,cas,sans_courbe); }; // écriture des pondérations éventuelles @@ -421,7 +420,7 @@ void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoriRelaxDyna::Ecrit_Base_info_Parametre(ostream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } @@ -435,10 +434,8 @@ void AlgoriRelaxDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i // choix = true : fonctionememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoriRelaxDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) - {// récup du flot - ifstream& ent = *entreePrinc.Ent_BI(); - string toto; +void AlgoriRelaxDyna::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) + {string toto; if (choix) {switch (cas) { case 1 : // ------- on récupère tout ------------------------- @@ -552,7 +549,7 @@ void AlgoriRelaxDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoriRelaxDyna::Lecture_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoriRelaxDyna::Lecture_Base_info_Parametre(istream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } @@ -1551,7 +1548,7 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -1561,8 +1558,8 @@ void AlgoriRelaxDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; }; // ajout d'un conteneur pour les coordonnées à l'itération 0 diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.h b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.h index c435339..9ab0a74 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.h +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_relax_dyna.h @@ -264,14 +264,14 @@ class AlgoriRelaxDyna : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc index 395e0e2..0a6c732 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.cc @@ -510,17 +510,15 @@ void AlgoriTchamwa::lecture_Parametres(UtilLecture& entreePrinc) // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrit uniquement les données variables (supposées comme telles) -void AlgoriTchamwa::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void AlgoriTchamwa::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { - // récup du flot - ofstream * sort = entreePrinc.Sort_BI(); // (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); if (cas == 1) { // ecriture du parametre - *(sort) << " phi= " << paraTypeCalcul(1) << " " << "typeCalEqui= " << type_cal_equilibre << " "; + sort << " phi= " << paraTypeCalcul(1) << " " << "typeCalEqui= " << type_cal_equilibre << " "; if (type_cal_equilibre == 2) - {*(sort) << " CGamma_pourVarPhi " << nom_courbe_CGamma_pourVarPhi; + {sort << " CGamma_pourVarPhi " << nom_courbe_CGamma_pourVarPhi; }; }; // (*sort) << "\n fin_parametres_algo_specifiques_ "; @@ -532,42 +530,41 @@ void AlgoriTchamwa::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoriTchamwa::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) +void AlgoriTchamwa::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) {if (cas == 1) {// dimensionnement paraTypeCalcul.Change_taille(1); if (choix) {// cas d'une lecture normale // récup du flot - ifstream * ent = entreePrinc.Ent_BI(); string toto; // lecture du parametre - *(ent) >> toto ; + ent >> toto ; if (toto != "phi=") { cout << "\n erreur en lecture du parametre de l'algorithme explicite: tchamwa" << "\n on attendait le mot : phi= , au lieu de " << toto << "\n AlgoriTchamwa::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> paraTypeCalcul(1) ; + ent >> paraTypeCalcul(1) ; // lecture du type d'équilibre - *(ent) >> toto ; + ent >> toto ; if (toto != "typeCalEqui=") { cout << "\n erreur en lecture du parametre typeCalEqui: tchamwa" << "\n on attendait le mot : typeCalEqui= , au lieu de " << toto << "\n AlgoriTchamwa::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> type_cal_equilibre ; + ent >> type_cal_equilibre ; if (type_cal_equilibre == 2) - { *(ent) >> toto; + { ent >> toto; if (toto != " CGamma_pourVarPhi ") { cout << "\n erreur en lecture de la fonction CGamma_pourVarPhi," << " on attendait CGamma_pourVarPhi et on a lue " << toto << "\n AlgoriTchamwa::Lecture_base_info_loi(..."; Sortie(1); }; - *(ent) >> nom_courbe_CGamma_pourVarPhi; + ent >> nom_courbe_CGamma_pourVarPhi; }; } else @@ -1074,7 +1071,7 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -1085,8 +1082,8 @@ void AlgoriTchamwa::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h index 5d0b6b3..ee0cce6 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa.h @@ -238,14 +238,14 @@ class AlgoriTchamwa : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc index a02439f..adf9bf4 100644 --- a/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc +++ b/Algo/GalerkinContinu/AlgoDynaExplicite/Algori_tchamwa2.cc @@ -209,7 +209,7 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -219,8 +219,8 @@ void AlgoriTchamwa::Calcul_Equilibre2(ParaGlob * paraGlob,LesMaillages * lesMail else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- @@ -792,7 +792,7 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -802,8 +802,8 @@ void AlgoriTchamwa::Calcul_Equilibre4(ParaGlob * paraGlob,LesMaillages * lesMail else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- diff --git a/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc b/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc index 90c3aac..89ea517 100644 --- a/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc +++ b/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc @@ -609,19 +609,16 @@ void AlgoriNewmark::lecture_Parametres(UtilLecture& entreePrinc) // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) -void AlgoriNewmark::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void AlgoriNewmark::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { - // récup du flot - ofstream * sort = entreePrinc.Sort_BI(); -// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); if (cas == 1) { // ecriture des parametres - *(sort) << " beta_et_gamma= " << paraTypeCalcul(1) << " " - << paraTypeCalcul(2) << " "; + sort << " beta_et_gamma= " << paraTypeCalcul(1) << " " + << paraTypeCalcul(2) << " "; // écriture du paramètre hht - *(sort) << " hht= " << paraTypeCalcul(3) << " "; + sort << " hht= " << paraTypeCalcul(3) << " "; // et le paramètre - *(sort) << " cL_a_chaque_iteration "<< cL_a_chaque_iteration << " "; + sort << " cL_a_chaque_iteration "<< cL_a_chaque_iteration << " "; }; // (*sort) << "\n fin_parametres_algo_specifiques_ "; }; @@ -632,35 +629,33 @@ void AlgoriNewmark::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoriNewmark::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) +void AlgoriNewmark::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) {if (cas == 1) {// dimensionnement paraTypeCalcul.Change_taille(3); if (choix) {// cas d'une lecture normale - // récup du flot - ifstream * ent = entreePrinc.Ent_BI(); string toto; // lecture du premier parametre - *(ent) >> toto ; + ent >> toto ; if (toto != "beta_et_gamma=") { cout << "\n erreur en lecture du parametre de l'algorithme explicite " << "\n on attendait le mot : beta_et_gamma= , au lieu de " << toto << "\n AlgoriNewmark::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> paraTypeCalcul(1) >> paraTypeCalcul(2); + ent >> paraTypeCalcul(1) >> paraTypeCalcul(2); // idem pour le paramètre hht - *(ent) >> toto >> paraTypeCalcul(3); + ent >> toto >> paraTypeCalcul(3); // lecture de cL_a_chaque_iteration - *(ent) >> toto ; + ent >> toto ; if (toto != "cL_a_chaque_iteration") { cout << "\n erreur en lecture du parametre cL_a_chaque_iteration" << "\n on attendait le mot : cL_a_chaque_iteration , au lieu de " << toto << "\n AlgoriNewmark::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> cL_a_chaque_iteration ; + ent >> cL_a_chaque_iteration ; } else {// cas où la lecture n'est pas possible, attribution des valeurs par défaut diff --git a/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h b/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h index 15065a8..3524f7e 100644 --- a/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h +++ b/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.h @@ -236,14 +236,14 @@ class AlgoriNewmark : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc b/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc index 32acfb7..29a578e 100644 --- a/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc +++ b/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark2.cc @@ -334,7 +334,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -344,7 +344,7 @@ void AlgoriNewmark::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); }; }; //--fin cas de restart et/ou de sauvegarde-------- diff --git a/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.cc b/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.cc index c9c3c21..786f17f 100755 --- a/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.cc +++ b/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.cc @@ -456,7 +456,7 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -466,9 +466,9 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; + } //--fin cas de restart et/ou de sauvegarde-------- // choix de la matrice de masse, qui est en fait celle qui correspond au ddl Xi @@ -841,11 +841,8 @@ void AlgoristatExpli::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMai // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrit uniquement les données variables (supposées comme telles) -void AlgoristatExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) -{ // récup du flot - ofstream& sort = *entreePrinc.Sort_BI(); -// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); - switch (cas) +void AlgoristatExpli::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) +{ switch (cas) {case 1 : // ------- on sauvegarde tout ------------------------- { // ecriture du type de calcul d'équilibre @@ -864,7 +861,7 @@ void AlgoristatExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoristatExpli::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoristatExpli::Ecrit_Base_info_Parametre(ostream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } @@ -878,10 +875,8 @@ void AlgoristatExpli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const i // choix = true : fonctionememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoristatExpli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) -{// récup du flot - ifstream& ent = *entreePrinc.Ent_BI(); - string toto; +void AlgoristatExpli::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) +{string toto; if (choix) {switch (cas) {case 1 : // ------- on récupère tout ------------------------- @@ -905,7 +900,7 @@ void AlgoristatExpli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoristatExpli::Lecture_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoristatExpli::Lecture_Base_info_Parametre(istream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } diff --git a/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.h b/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.h index 2570c72..be3e714 100755 --- a/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.h +++ b/Algo/GalerkinContinu/AlgoMixte/AlgoriMixte.h @@ -220,14 +220,14 @@ class AlgoristatExpli : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques ///**** inexploitable pour l'instant void Info_commande_parametres(UtilLecture& entreePrinc){}; diff --git a/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc b/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc index 8da1fc7..8025881 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc +++ b/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.cc @@ -220,7 +220,7 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-‡-dire le premier incrÈment // aprËs s'Ítre positionnÈ au dÈbut du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -230,8 +230,8 @@ void AlgoriFlambLineaire::Execution(ParaGlob * paraGlob,LesMaillages * lesMail, else { // sinon on se place dans le fichier ‡ la position du restart // debut_increment a ÈtÈ dÈfinit dans algori (classe mËre) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- @@ -608,16 +608,13 @@ void AlgoriFlambLineaire::lecture_Parametres(UtilLecture& entreePrinc) // Ècriture des paramËtres dans la base info // = 1 : on Ècrit tout // = 2 : on Ècrot uniquement les donnÈes variables (supposÈes comme telles) -void AlgoriFlambLineaire::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void AlgoriFlambLineaire::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { - // récup du flot - ofstream * sort = entreePrinc.Sort_BI(); -// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); if (cas == 1) { // ecriture du parametre - *(sort) << "methode_et_nbDeValeurPropre= " << paraTypeCalcul(1) << " " - << paraTypeCalcul(2) << " "; + sort << "methode_et_nbDeValeurPropre= " << paraTypeCalcul(1) << " " + << paraTypeCalcul(2) << " "; }; // (*sort) << "\n fin_parametres_algo_specifiques_ "; @@ -629,17 +626,14 @@ void AlgoriFlambLineaire::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,con // choix = true : fonctionnememt normal // choix = false : la mÈthode ne doit pas lire mais initialiser les donnÈes ‡ leurs valeurs par dÈfaut // car la lecture est impossible -void AlgoriFlambLineaire::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) +void AlgoriFlambLineaire::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) {if (cas == 1) {// dimensionnement paraTypeCalcul.Change_taille(2); if (choix) - {// cas d'une lecture normale - // rÈcup du flot - ifstream * ent = entreePrinc.Ent_BI(); - string toto; + {string toto; // lecture du premier parametre - *(ent) >> toto ; + ent >> toto ; if (toto != "methode_et_nbDeValeurPropre=") { cout << "\n erreur en lecture du paramËtre de l'algorithme explicite " << "\n on attendait le mot : methode_et_nbDeValeurPropre= , au lieu de " @@ -647,7 +641,7 @@ void AlgoriFlambLineaire::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,c << "\n AlgoriFlambLineaire::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> paraTypeCalcul(1) >> paraTypeCalcul(2); + ent >> paraTypeCalcul(1) >> paraTypeCalcul(2); } else {// cas o˘ la lecture n'est pas possible, attribution des valeurs par dÈfaut diff --git a/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h b/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h index e70806c..e1f5f1b 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h +++ b/Algo/GalerkinContinu/AlgoStatiques/AlgoriFlambLineaire.h @@ -172,14 +172,14 @@ class AlgoriFlambLineaire : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) ; + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas) ; // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) ; + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) ; // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); }; diff --git a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc index ad026b8..dc7f084 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc +++ b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.cc @@ -574,14 +574,11 @@ void AlgoriNonDyna::lecture_Parametres(UtilLecture& entreePrinc) // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrit uniquement les données variables (supposées comme telles) -void AlgoriNonDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) +void AlgoriNonDyna::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) { - // récup du flot - ofstream * sort = entreePrinc.Sort_BI(); -// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); if (cas == 1) - {// ecriture du parametre - *(sort) << "\n acceleration_convergence= " << acceleration_convergence + { // ecriture du parametre + sort << "\n acceleration_convergence= " << acceleration_convergence << " cas_acceleration_convergence= " << cas_acceleration_convergence << " nb_vec_cycle= " << nb_vec_cycle << " nb_vec_cycle= " << nb_vec_cycle @@ -604,7 +601,7 @@ void AlgoriNonDyna::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoriNonDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) +void AlgoriNonDyna::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) { if (cas == 1) {// dimensionnement @@ -614,100 +611,97 @@ void AlgoriNonDyna::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const i << " en lecture, que l'on effectue "<< flush; }; - // cas d'une lecture normale - // récup du flot - ifstream * ent = entreePrinc.Ent_BI(); string toto; // lecture de acceleration_convergence - *(ent) >> toto ; + ent >> toto ; if (toto != "acceleration_convergence=") { cout << "\n erreur en lecture du parametre acceleration_convergence de l'algorithme implicite statique" << "\n on attendait le mot : acceleration_convergence= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> acceleration_convergence ; + ent >> acceleration_convergence ; // lecture de cas_acceleration_convergence - *(ent) >> toto ; + ent >> toto ; if (toto != "cas_acceleration_convergence=") { cout << "\n erreur en lecture du parametre cas_acceleration_convergence" << "\n on attendait le mot : acceleration_convergence= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> acceleration_convergence ; + ent >> acceleration_convergence ; // lecture de nb_vec_cycle - *(ent) >> toto ; + ent >> toto ; if (toto != "nb_vec_cycle=") { cout << "\n erreur en lecture du parametre nb_vec_cycle" << "\n on attendait le mot : nb_vec_cycle= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> nb_vec_cycle ; + ent >> nb_vec_cycle ; // lecture de deb_newton_modifie - *(ent) >> toto ; + ent >> toto ; if (toto != "deb_newton_modifie=") { cout << "\n erreur en lecture du parametre deb_newton_modifie" << "\n on attendait le mot : deb_newton_modifie= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> deb_newton_modifie ; + ent >> deb_newton_modifie ; // lecture de fin_newton_modifie - *(ent) >> toto ; + ent >> toto ; if (toto != "fin_newton_modifie=") { cout << "\n erreur en lecture du parametre fin_newton_modifie" << "\n on attendait le mot : fin_newton_modifie= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> fin_newton_modifie ; + ent >> fin_newton_modifie ; // lecture de nb_iter_NM - *(ent) >> toto ; + ent >> toto ; if (toto != "nb_iter_NM=") { cout << "\n erreur en lecture du parametre nb_iter_NM" << "\n on attendait le mot : nb_iter_NM= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> nb_iter_NM ; + ent >> nb_iter_NM ; // lecture de deb_raideur_moyenne - *(ent) >> toto ; + ent >> toto ; if (toto != "deb_raideur_moyenne=") { cout << "\n erreur en lecture du parametre deb_raideur_moyenne" << "\n on attendait le mot : deb_raideur_moyenne= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> deb_raideur_moyenne ; + ent >> deb_raideur_moyenne ; // lecture de fin_raideur_moyenne - *(ent) >> toto ; + ent >> toto ; if (toto != "fin_raideur_moyenne=") { cout << "\n erreur en lecture du parametre fin_raideur_moyenne" << "\n on attendait le mot : fin_raideur_moyenne= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> fin_raideur_moyenne ; + ent >> fin_raideur_moyenne ; // lecture de nb_raideur_moyenne - *(ent) >> toto ; + ent >> toto ; if (toto != "nb_raideur_moyenne=") { cout << "\n erreur en lecture du parametre nb_raideur_moyenne" << "\n on attendait le mot : nb_raideur_moyenne= , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> nb_raideur_moyenne ; + ent >> nb_raideur_moyenne ; // lecture de cL_a_chaque_iteration - *(ent) >> toto ; + ent >> toto ; if (toto != "cL_a_chaque_iteration") { cout << "\n erreur en lecture du parametre cL_a_chaque_iteration" << "\n on attendait le mot : cL_a_chaque_iteration , au lieu de " << toto << "\n AlgoriNonDyna::Lecture_Base_info_Parametre( ... "; Sortie(1); } - *(ent) >> cL_a_chaque_iteration ; + ent >> cL_a_chaque_iteration ; } else {// cas où la lecture n'est pas possible, attribution des valeurs par défaut diff --git a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h index 6e4286f..8c82e00 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h +++ b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna.h @@ -229,14 +229,14 @@ class AlgoriNonDyna : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc index 0278725..5b20a34 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc +++ b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc @@ -423,7 +423,7 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -433,7 +433,7 @@ void AlgoriNonDyna::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); }; }; @@ -1938,7 +1938,7 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -1948,8 +1948,8 @@ void AlgoriNonDyna::Calcul_Equilibre_longueur_arc else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + }; } //--fin cas de restart et/ou de sauvegarde-------- OrdreVisu::EnumTypeIncre type_incre = OrdreVisu::PREMIER_INCRE; // pour la visualisation au fil du calcul diff --git a/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc b/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc index 871a18d..5f2d872 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc +++ b/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.cc @@ -308,7 +308,8 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { int position = 0; + entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -318,8 +319,8 @@ void ImpliNonDynaCont::Calcul_Equilibre(ParaGlob * paraGlob,LesMaillages * lesMa else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); - } + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); + } } //--fin cas de restart et/ou de sauvegarde-------- diff --git a/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h b/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h index a92d1d6..7d032f3 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h +++ b/Algo/GalerkinContinu/AlgoStatiques/ImpliNonDynaCont.h @@ -156,12 +156,12 @@ class ImpliNonDynaCont : public Algori private : // METHODES PROTEGEES : // écriture des paramètres dans la base info (ici rien) - void Ecrit_Base_info_Parametre(UtilLecture& ,const int& ) {}; + void Ecrit_Base_info_Parametre(ostream& ,const int& ) {}; // lecture des paramètres dans la base info (ici rien) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& ,const int& ,bool ) {}; + void Lecture_Base_info_Parametre(istream& ,const int& ,bool ) {}; // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc) {Algori::Info_com_parametres(entreePrinc);}; diff --git a/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc b/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc index 85dea8d..524418e 100644 --- a/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc +++ b/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.cc @@ -239,11 +239,8 @@ void AlgoBonelli::Execution(ParaGlob * paraGlob,LesMaillages * lesMail // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) -void AlgoBonelli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas) -{ // récup du flot - ofstream& sort = *entreePrinc.Sort_BI(); -// sort << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul()); - switch (cas) +void AlgoBonelli::Ecrit_Base_info_Parametre(ostream& sort,const int& cas) +{ switch (cas) {case 1 : // ------- on sauvegarde tout ------------------------- { // ecriture des parametres de l'algorithme @@ -257,7 +254,7 @@ void AlgoBonelli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& } default : {// cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoBonelli::Ecrit_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoBonelli::Ecrit_Base_info_Parametre(ostream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } @@ -271,10 +268,8 @@ void AlgoBonelli::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& // choix = true : fonctionememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible -void AlgoBonelli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix) -{// récup du flot - ifstream& ent = *entreePrinc.Ent_BI(); - string toto; +void AlgoBonelli::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix) +{string toto; if (choix) {switch (cas) {case 1 : // ------- on récupère tout ------------------------- @@ -291,7 +286,7 @@ void AlgoBonelli::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "AlgoBonelli::Lecture_Base_info_Parametre(UtilLecture& ,const int& )" + cout << "AlgoBonelli::Lecture_Base_info_Parametre(istream& ,const int& )" << " cas= " << cas << endl; Sortie(1); } @@ -861,7 +856,7 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, // c'est-à-dire le premier incrément // après s'être positionné au début du fichier if (this->Num_restart() == 0) - { (entreePrinc->Sort_BI())->seekp(0); + { entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier); int cas = 1; paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas); this->Ecriture_base_info @@ -871,7 +866,7 @@ void AlgoBonelli::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail, else { // sinon on se place dans le fichier à la position du restart // debut_increment a été définit dans algori (classe mère) - (entreePrinc->Sort_BI())->seekp(debut_increment); + entreePrinc->Sort_BI_Positionnement_offset(debut_increment); } } //--fin cas de restart et/ou de sauvegarde-------- diff --git a/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h b/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h index e7df9f0..29d8ddb 100644 --- a/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h +++ b/Algo/GalerkinDiscontinu/DG_DynaExplicite/AlgoBonelli.h @@ -242,14 +242,14 @@ class AlgoBonelli : public Algori // écriture des paramètres dans la base info // = 1 : on écrit tout // = 2 : on écrot uniquement les données variables (supposées comme telles) - void Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas); + void Ecrit_Base_info_Parametre(ostream& sort,const int& cas); // lecture des paramètres dans la base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) // choix = true : fonctionnememt normal // choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut // car la lecture est impossible - void Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix); + void Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix); // création d'un fichier de commande: cas des paramètres spécifiques void Info_commande_parametres(UtilLecture& entreePrinc); diff --git a/Chargement/BlocCharge_T.h b/Chargement/BlocCharge_T.h index 90c2363..ef96455 100644 --- a/Chargement/BlocCharge_T.h +++ b/Chargement/BlocCharge_T.h @@ -170,7 +170,7 @@ class BlocCharge : public Bloc_particulier // affichage et definition interactive des commandes // attribut : donne un attribut éventuel à afficher dans les choix - void Info_commande_BlocCharge(ofstream & sort,string attribut = "_"); + void Info_commande_BlocCharge(ostream & sort,string attribut = "_"); // mise en place de l'association des fonctions nD, dont ensuite on garde un pointeur // en retour indique si l'association est ok @@ -510,7 +510,7 @@ bool BlocCharge::operator /// attrib : donne un attribut éventuel à afficher dans les choix template void BlocCharge::Info_commande_BlocCharge - (ofstream & sort,string attrib) + (ostream & sort,string attrib) { //On va proposer un menu string rep=" "; co_charge="_"; diff --git a/Chargement/Charge.cc b/Chargement/Charge.cc index dc131b2..c591abf 100644 --- a/Chargement/Charge.cc +++ b/Chargement/Charge.cc @@ -1133,7 +1133,7 @@ void Charge::Initialise(LesMaillages * lesmail,LesReferences* lesRef,ParaAlgoCon // lecture base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Charge::Lecture_base_info(ifstream& entr,const int cas,LesReferences& ,LesCourbes1D& lesCourbes1D +void Charge::Lecture_base_info(istream& entr,const int cas,LesReferences& ,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) {switch (cas) { case 1 : // ------- on récupère tout ------------------------- @@ -1229,7 +1229,7 @@ void Charge::Lecture_base_info(ifstream& entr,const int cas,LesReferences& ,LesC } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "Charge::Lecture_base_info(ifstream& entr,const int cas)" + cout << "Charge::Lecture_base_info(istream& entr,const int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -1239,7 +1239,7 @@ void Charge::Lecture_base_info(ifstream& entr,const int cas,LesReferences& ,LesC // écriture base info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Charge::Ecriture_base_info(ofstream& sort,const int cas) +void Charge::Ecriture_base_info(ostream& sort,const int cas) {switch (cas) { case 1 : // ------- on sauvegarde tout ------------------------- { sort << "\n ****chargement \n" ; @@ -1313,7 +1313,7 @@ void Charge::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "Charge::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "Charge::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Chargement/Charge.h b/Chargement/Charge.h index 380b5d7..ec063e5 100644 --- a/Chargement/Charge.h +++ b/Chargement/Charge.h @@ -305,12 +305,12 @@ class Charge // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); private : // VARIABLES PROTEGEES : diff --git a/Chargement/VariablesTemps.cc b/Chargement/VariablesTemps.cc index 20bf03e..d7ccdba 100644 --- a/Chargement/VariablesTemps.cc +++ b/Chargement/VariablesTemps.cc @@ -63,7 +63,7 @@ void VariablesTemps::Affiche() const // = 2 : on récupère uniquement les données variables (supposées comme telles) // = 3 : on met à jour uniquement les données variables (supposées comme telles) // dans ce cas il y a modification des grandeurs, mais pas redimentionnement -void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas) +void VariablesTemps::Lecture_base_info_temps(istream& entr,const int cas) {switch (cas) { case 1 : // ------- on récupère tout ------------------------- { cout << "== lecture des variables temps \n"; @@ -82,7 +82,7 @@ void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas) } default : {cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "VariablesTemps::Lecture_base_info(ifstream& entr,const int cas)" + cout << "VariablesTemps::Lecture_base_info(istream& entr,const int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -90,7 +90,7 @@ void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas) }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void VariablesTemps::Ecriture_base_info_temps(ofstream& sort,const int cas) const +void VariablesTemps::Ecriture_base_info_temps(ostream& sort,const int cas) const {switch (cas) { case 1 : // ------- on sauvegarde tout ------------------------- { sort << " ****info_temps " ; @@ -109,7 +109,7 @@ void VariablesTemps::Ecriture_base_info_temps(ofstream& sort,const int cas) cons } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "VariablesTemps::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "VariablesTemps::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Chargement/VariablesTemps.h b/Chargement/VariablesTemps.h index a2b34f4..438fdaa 100644 --- a/Chargement/VariablesTemps.h +++ b/Chargement/VariablesTemps.h @@ -116,11 +116,11 @@ class VariablesTemps // = 2 : on récupère uniquement les données variables (supposées comme telles) // = 3 : on met à jour uniquement les données variables (supposées comme telles) // dans ce cas il y a modification des grandeurs, mais pas redimentionnement - void Lecture_base_info_temps(ifstream& ent,const int cas); + void Lecture_base_info_temps(istream& ent, int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_temps(ofstream& sort,const int cas) const ; + void Ecriture_base_info_temps(ostream& sort,int cas) const ; protected : // VARIABLES PROTEGEES : diff --git a/Elements/Element.cc b/Elements/Element.cc index d75d91a..4d3c9f3 100644 --- a/Elements/Element.cc +++ b/Elements/Element.cc @@ -1487,7 +1487,7 @@ void Element::Info_com_El // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Element::Lect_bas_inf_element - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {switch (cas) { case 1 : // ------- on récupère tout ------------------------- { // le tableau de connection des noeuds @@ -1663,7 +1663,7 @@ void Element::Lect_bas_inf_element // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Element::Ecri_bas_inf_element(ofstream& sort,const int cas) +void Element::Ecri_bas_inf_element(ostream& sort,const int cas) { // en fait ici on sauvegarde la même chose dans tous les cas, par contre la sortie // totale est documentée. switch (cas) @@ -1718,7 +1718,7 @@ void Element::Ecri_bas_inf_element(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas)" + cout << "ElemMeca::Ecriture_bas_inf(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Element.h b/Elements/Element.h index 8de3faa..6b835bd 100644 --- a/Elements/Element.h +++ b/Elements/Element.h @@ -537,7 +537,7 @@ class Element // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - virtual void AfficheVarDual(ofstream& sort, Tableau& nom) = 0; + virtual void AfficheVarDual(ostream& sort, Tableau& nom) = 0; // retourne un numero d'ordre d'un point le plus près ou est exprimé la grandeur enum // par exemple un point d'intégration, mais n'est utilisable qu'avec des méthodes particulières @@ -879,11 +879,11 @@ class Element // = 2 : on récupère uniquement les données variables (supposées comme telles) // tabMaillageNoeud : contiend les noeuds du maillage de définition de l'élément virtual void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) = 0; + (istream& ent,const Tableau * tabMaillageNoeud, int cas) = 0; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas) = 0; + virtual void Ecriture_base_info(ostream& sort, int cas) = 0; //-------------- pour modification d'éléments --------------------------- // définition d'un conteneur pour la définition d'un type d'élément @@ -1103,11 +1103,11 @@ class Element // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lect_bas_inf_element - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecri_bas_inf_element(ofstream& sort,const int cas) ; + void Ecri_bas_inf_element(ostream& sort,const int cas) ; // ---------------- concernant les frontières ---------------- diff --git a/Elements/Geometrie/Frontiere/ElFrontiere.cc b/Elements/Geometrie/Frontiere/ElFrontiere.cc index 06a679f..ef03f29 100644 --- a/Elements/Geometrie/Frontiere/ElFrontiere.cc +++ b/Elements/Geometrie/Frontiere/ElFrontiere.cc @@ -455,7 +455,7 @@ bool ElFrontiere::Projection_normale(const Coordonnee& A, Coordonnee& P) // pour l'instant on ne sauvegarde rien car ce n'est pas une bonne idée, et cela ne servira a rien // lecture base info -void ElFrontiere::Lecture_base_info_ElFrontiere(ifstream& ent) +void ElFrontiere::Lecture_base_info_ElFrontiere(istream& ent) { /*// lecture du type et vérification string nom_type; ent >> nom_type; @@ -485,7 +485,7 @@ void ElFrontiere::Lecture_base_info_ElFrontiere(ifstream& ent) }; // écriture base info -void ElFrontiere::Ecriture_base_info_ElFrontiere(ofstream& sort ) +void ElFrontiere::Ecriture_base_info_ElFrontiere(ostream& sort ) { /*// un identificateur de type sort << "ElFrontiere \n"; // le tableau de noeud associé à l'élément frontière diff --git a/Elements/Geometrie/Frontiere/ElFrontiere.h b/Elements/Geometrie/Frontiere/ElFrontiere.h index 74a580c..beb1f04 100644 --- a/Elements/Geometrie/Frontiere/ElFrontiere.h +++ b/Elements/Geometrie/Frontiere/ElFrontiere.h @@ -231,13 +231,13 @@ class ElFrontiere //----- lecture écriture de restart ----- // ceci concerne uniquement les informations de la classe générique - void Lecture_base_info_ElFrontiere(ifstream& ent); - void Ecriture_base_info_ElFrontiere(ofstream& sort); + void Lecture_base_info_ElFrontiere(istream& ent); + void Ecriture_base_info_ElFrontiere(ostream& sort); // ceci concerne uniquement les informations spécifiques des classes dérivées // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - virtual void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) = 0; - virtual void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) = 0; + virtual void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) = 0; + virtual void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) = 0; protected : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Front.cc b/Elements/Geometrie/Frontiere/Front.cc index f0f0a13..b653e96 100644 --- a/Elements/Geometrie/Frontiere/Front.cc +++ b/Elements/Geometrie/Frontiere/Front.cc @@ -250,7 +250,7 @@ bool Front::In_boite_emcombrement_front(const Coordonnee& M,double extra) const // ici la lecture n'est pas complète il faut ensuite changer l'élément // frontière et changer le pointeur de l'élément finis // -> utilisation de : Change_elem_frontiere, Change_PtEI -void Front::Lecture_base_info_front(ifstream& ent) +void Front::Lecture_base_info_front(istream& ent) { // lecture et vérification du type string nom_type; ent >> nom_type; @@ -273,7 +273,7 @@ void Front::Lecture_base_info_front(ifstream& ent) // écriture base info // on ne sauvegarde ici que les grandeurs spécifiques à ce niveau // concernant les infos relatives à l'élément, la frontière, etc, ce n'est pas traité ici, mais au niveau de la classe LesContats -void Front::Ecriture_base_info_front(ofstream& sort) +void Front::Ecriture_base_info_front(ostream& sort) { // écriture du type sort << "Front "; // les données diff --git a/Elements/Geometrie/Frontiere/Front.h b/Elements/Geometrie/Frontiere/Front.h index c043abb..3041ec4 100644 --- a/Elements/Geometrie/Frontiere/Front.h +++ b/Elements/Geometrie/Frontiere/Front.h @@ -148,12 +148,12 @@ class Front class Signature_Front { public: int numelem; int numMail;}; // la lecture s'effectue uniquement au niveau de la signature // 1) lecture et retour de la signature - Signature_Front Lecture_base_info_Signature_Front(ifstream& ent); + Signature_Front Lecture_base_info_Signature_Front(istream& ent); // ici la lecture n'est pas complète il faut ensuite mettre à jour l'élément // frontière en fonction de son numéro qui est déjà stocké dans l'élément, et le pointeur de l'élément // -> utilisation de : Change_elem_frontiere, Change_PtEI - void Lecture_base_info_front(ifstream& ent); - void Ecriture_base_info_front(ofstream& sort); + void Lecture_base_info_front(istream& ent); + void Ecriture_base_info_front(ostream& sort); // changement d'élément frontière, il faut également le numéro de l'élément fini associé void Change_elem_frontiere(const ElFrontiere& el, int num_front) diff --git a/Elements/Geometrie/Frontiere/Ligne/FrontSegCub.cc b/Elements/Geometrie/Frontiere/Ligne/FrontSegCub.cc index 2cc9ff2..f773442 100644 --- a/Elements/Geometrie/Frontiere/Ligne/FrontSegCub.cc +++ b/Elements/Geometrie/Frontiere/Ligne/FrontSegCub.cc @@ -403,11 +403,11 @@ double FrontSegCub::LongueurApprox() //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontSegCub::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontSegCub::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> droite >> toto >> theta; }; -void FrontSegCub::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontSegCub::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontSC " ; sort << " dr_tg " << droite << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Ligne/FrontSegCub.h b/Elements/Geometrie/Frontiere/Ligne/FrontSegCub.h index 1118a37..b7305f8 100644 --- a/Elements/Geometrie/Frontiere/Ligne/FrontSegCub.h +++ b/Elements/Geometrie/Frontiere/Ligne/FrontSegCub.h @@ -148,8 +148,8 @@ class FrontSegCub : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.cc b/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.cc index 3060f02..bbd07fc 100644 --- a/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.cc +++ b/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.cc @@ -372,11 +372,11 @@ double FrontSegLine::LongueurApprox() //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontSegLine::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontSegLine::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> droite >> toto >> Mp >> toto >> theta; }; -void FrontSegLine::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontSegLine::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontSL " ; sort << " dr_tg " << droite << " Mp " << Mp << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.h b/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.h index 77f472d..5e3f6ae 100644 --- a/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.h +++ b/Elements/Geometrie/Frontiere/Ligne/FrontSegLine.h @@ -151,8 +151,8 @@ class FrontSegLine : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.cc b/Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.cc index b0b41c1..3a7bb03 100644 --- a/Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.cc +++ b/Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.cc @@ -476,11 +476,11 @@ double FrontSegQuad::LongueurApprox() //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontSegQuad::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontSegQuad::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> droite >> toto >> theta; }; -void FrontSegQuad::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontSegQuad::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontSQ " ; sort << " dr_tg " << droite << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.h b/Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.h index 3a60bb0..84c4e1c 100644 --- a/Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.h +++ b/Elements/Geometrie/Frontiere/Ligne/FrontSegQuad.h @@ -148,8 +148,8 @@ class FrontSegQuad : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Point/FrontPointF.cc b/Elements/Geometrie/Frontiere/Point/FrontPointF.cc index f34ce2d..b2087d0 100644 --- a/Elements/Geometrie/Frontiere/Point/FrontPointF.cc +++ b/Elements/Geometrie/Frontiere/Point/FrontPointF.cc @@ -101,7 +101,7 @@ Tableau & FrontPointF::Frontiere() //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontPointF::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontPointF::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; int test; ent >> toto >> test ; if (test) @@ -112,7 +112,7 @@ void FrontPointF::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) { if (T != NULL) delete T;}; }; -void FrontPointF::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontPointF::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontPointF " ; if (T != NULL) { sort << " 1 " << *T ;} diff --git a/Elements/Geometrie/Frontiere/Point/FrontPointF.h b/Elements/Geometrie/Frontiere/Point/FrontPointF.h index dc57074..8d91270 100644 --- a/Elements/Geometrie/Frontiere/Point/FrontPointF.h +++ b/Elements/Geometrie/Frontiere/Point/FrontPointF.h @@ -195,8 +195,8 @@ class FrontPointF : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Surface/FrontQuadCC.cc b/Elements/Geometrie/Frontiere/Surface/FrontQuadCC.cc index 8d294c4..f6ecb05 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontQuadCC.cc +++ b/Elements/Geometrie/Frontiere/Surface/FrontQuadCC.cc @@ -361,11 +361,11 @@ void FrontQuadCC::Affiche(Enum_dure temp) const //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontQuadCC::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontQuadCC::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> plan >> toto >> theta; }; -void FrontQuadCC::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontQuadCC::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontQCC " ; sort << " pl_tg " << plan << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Surface/FrontQuadCC.h b/Elements/Geometrie/Frontiere/Surface/FrontQuadCC.h index be7c011..f611cc2 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontQuadCC.h +++ b/Elements/Geometrie/Frontiere/Surface/FrontQuadCC.h @@ -141,8 +141,8 @@ class FrontQuadCC : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.cc b/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.cc index 8675513..98e4c92 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.cc +++ b/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.cc @@ -379,11 +379,11 @@ void FrontQuadLine::Affiche(Enum_dure temp) const //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontQuadLine::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontQuadLine::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> plan >> toto >> theta; }; -void FrontQuadLine::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontQuadLine::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontQL " ; sort << " pl_tg " << plan << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.h b/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.h index d6ee149..46d3fc3 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.h +++ b/Elements/Geometrie/Frontiere/Surface/FrontQuadLine.h @@ -140,8 +140,8 @@ class FrontQuadLine : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Surface/FrontQuadQC.cc b/Elements/Geometrie/Frontiere/Surface/FrontQuadQC.cc index 451e9f6..6bf07b3 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontQuadQC.cc +++ b/Elements/Geometrie/Frontiere/Surface/FrontQuadQC.cc @@ -382,11 +382,11 @@ void FrontQuadQC::Affiche(Enum_dure temp) const //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontQuadQC::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontQuadQC::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> plan >> toto >> theta; }; -void FrontQuadQC::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontQuadQC::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontQC " ; sort << " pl_tg " << plan << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Surface/FrontQuadQC.h b/Elements/Geometrie/Frontiere/Surface/FrontQuadQC.h index 3b8b405..544eab1 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontQuadQC.h +++ b/Elements/Geometrie/Frontiere/Surface/FrontQuadQC.h @@ -141,8 +141,8 @@ class FrontQuadQC : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.cc b/Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.cc index d3f6c12..9283b3e 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.cc +++ b/Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.cc @@ -377,11 +377,11 @@ void FrontQuadQuad::Affiche(Enum_dure temp) const //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontQuadQuad::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontQuadQuad::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> plan >> toto >> theta; }; -void FrontQuadQuad::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontQuadQuad::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontQQ " ; sort << " pl_tg " << plan << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.h b/Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.h index 893f031..18fc60b 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.h +++ b/Elements/Geometrie/Frontiere/Surface/FrontQuadQuad.h @@ -141,8 +141,8 @@ class FrontQuadQuad : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Surface/FrontTriaLine.cc b/Elements/Geometrie/Frontiere/Surface/FrontTriaLine.cc index 70f6494..bd1c4fc 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontTriaLine.cc +++ b/Elements/Geometrie/Frontiere/Surface/FrontTriaLine.cc @@ -367,11 +367,11 @@ void FrontTriaLine::Affiche(Enum_dure temp) const //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontTriaLine::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontTriaLine::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> plan >> toto >> theta; }; -void FrontTriaLine::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontTriaLine::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontTL " ; sort << " pl_tg " << plan << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Surface/FrontTriaLine.h b/Elements/Geometrie/Frontiere/Surface/FrontTriaLine.h index 25b0430..44179c5 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontTriaLine.h +++ b/Elements/Geometrie/Frontiere/Surface/FrontTriaLine.h @@ -138,8 +138,8 @@ class FrontTriaLine : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent); - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort); + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent); + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort); private : // VARIABLES PROTEGEES : diff --git a/Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.cc b/Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.cc index d3666a0..701d608 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.cc +++ b/Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.cc @@ -376,11 +376,11 @@ void FrontTriaQuad::Affiche(Enum_dure temp) const //----- lecture écriture de restart ----- // ceci concerne uniquement les informations spécifiques -void FrontTriaQuad::Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) +void FrontTriaQuad::Lecture_base_info_ElFrontiere_pour_projection(istream& ent) { string toto; ent >> toto >> toto >> plan >> toto >> theta; }; -void FrontTriaQuad::Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) +void FrontTriaQuad::Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) { sort << " FrontTQ " ; sort << " pl_tg " << plan << " theta " << theta ; }; diff --git a/Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.h b/Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.h index aa62bdd..061bc2f 100644 --- a/Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.h +++ b/Elements/Geometrie/Frontiere/Surface/FrontTriaQuad.h @@ -139,8 +139,8 @@ class FrontTriaQuad : public ElFrontiere // ceci concerne uniquement les informations spécifiques // dans le cas de l'utilisation de la frontière pour la projection d'un point sur la frontière // il s'agit donc d'un cas particulier - void Lecture_base_info_ElFrontiere_pour_projection(ifstream& ent) ; - void Ecriture_base_info_ElFrontiere_pour_projection(ofstream& sort) ; + void Lecture_base_info_ElFrontiere_pour_projection(istream& ent) ; + void Ecriture_base_info_ElFrontiere_pour_projection(ostream& sort) ; private : // VARIABLES PROTEGEES : diff --git a/Elements/Mecanique/Biellette/Biel_axi.cc b/Elements/Mecanique/Biellette/Biel_axi.cc index 0c1613e..4750cc4 100755 --- a/Elements/Mecanique/Biellette/Biel_axi.cc +++ b/Elements/Mecanique/Biellette/Biel_axi.cc @@ -628,7 +628,7 @@ const DeuxCoordonnees& Biel_axi::Boite_encombre_element(Enum_dure temps) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Biel_axi::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de la biellette @@ -659,7 +659,7 @@ void Biel_axi::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "Biel_axi::Lecture_base_info(ofstream& sort,int cas)" + cout << "Biel_axi::Lecture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -669,7 +669,7 @@ void Biel_axi::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Biel_axi::Ecriture_base_info(ofstream& sort,const int cas) +void Biel_axi::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de la biellette @@ -692,7 +692,7 @@ void Biel_axi::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "Biel_axi::Ecriture_base_info(ofstream& sort,int cas)" + cout << "Biel_axi::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -863,7 +863,7 @@ Element* Biel_axi::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const B // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void Biel_axi::AfficheVarDual(ofstream& sort, Tableau& nom) + void Biel_axi::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element bielette (2 noeuds"<& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // affichage d'info en fonction de ordre // ordre = "commande" : affichage d'un exemple d'entree pour l'élément @@ -249,11 +249,11 @@ class Biel_axi : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // METHODES VIRTUELLES: // --------- calculs utils dans le cadre de la recherche du flambement linéaire diff --git a/Elements/Mecanique/Biellette/Biel_axiQ.cc b/Elements/Mecanique/Biellette/Biel_axiQ.cc index 2b954f5..8037aa5 100755 --- a/Elements/Mecanique/Biellette/Biel_axiQ.cc +++ b/Elements/Mecanique/Biellette/Biel_axiQ.cc @@ -628,7 +628,7 @@ const DeuxCoordonnees& Biel_axiQ::Boite_encombre_element(Enum_dure temps) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Biel_axiQ::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de la biellette @@ -659,7 +659,7 @@ void Biel_axiQ::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "Biel_axiQ::Lecture_base_info(ofstream& sort,int cas)" + cout << "Biel_axiQ::Lecture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -669,7 +669,7 @@ void Biel_axiQ::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Biel_axiQ::Ecriture_base_info(ofstream& sort,const int cas) +void Biel_axiQ::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de la biellette @@ -692,7 +692,7 @@ void Biel_axiQ::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "Biel_axiQ::Ecriture_base_info(ofstream& sort,int cas)" + cout << "Biel_axiQ::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -862,7 +862,7 @@ Element* Biel_axiQ::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void Biel_axiQ::AfficheVarDual(ofstream& sort, Tableau& nom) + void Biel_axiQ::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element bielette ("<& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // affichage d'info en fonction de ordre // ordre = "commande" : affichage d'un exemple d'entree pour l'élément @@ -250,11 +250,11 @@ class Biel_axiQ : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // METHODES VIRTUELLES: // --------- calculs utils dans le cadre de la recherche du flambement linéaire diff --git a/Elements/Mecanique/Biellette/Biellette.cc b/Elements/Mecanique/Biellette/Biellette.cc index 0d9a14d..6e315b4 100644 --- a/Elements/Mecanique/Biellette/Biellette.cc +++ b/Elements/Mecanique/Biellette/Biellette.cc @@ -599,7 +599,7 @@ const DeuxCoordonnees& Biellette::Boite_encombre_element(Enum_dure temps) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Biellette::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de la biellette @@ -630,7 +630,7 @@ void Biellette::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "Biellette::Lecture_base_info(ofstream& sort,int cas)" + cout << "Biellette::Lecture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -640,7 +640,7 @@ void Biellette::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Biellette::Ecriture_base_info(ofstream& sort,const int cas) +void Biellette::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de la biellette @@ -664,7 +664,7 @@ void Biellette::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "Biellette::Ecriture_base_info(ofstream& sort,int cas)" + cout << "Biellette::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -851,7 +851,7 @@ Element* Biellette::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void Biellette::AfficheVarDual(ofstream& sort, Tableau& nom) + void Biellette::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element bielette (2 noeuds 1 point d'integration) "; diff --git a/Elements/Mecanique/Biellette/Biellette.h b/Elements/Mecanique/Biellette/Biellette.h index 31fee93..0a6d101 100644 --- a/Elements/Mecanique/Biellette/Biellette.h +++ b/Elements/Mecanique/Biellette/Biellette.h @@ -200,7 +200,7 @@ class Biellette : public ElemMeca // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // affichage d'info en fonction de ordre // ordre = "commande" : affichage d'un exemple d'entree pour l'élément @@ -246,11 +246,11 @@ class Biellette : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,int cas) ; // METHODES VIRTUELLES: // --------- calculs utils dans le cadre de la recherche du flambement linéaire diff --git a/Elements/Mecanique/Biellette/BielletteC1.cc b/Elements/Mecanique/Biellette/BielletteC1.cc index 7e4f259..7ddc6b0 100644 --- a/Elements/Mecanique/Biellette/BielletteC1.cc +++ b/Elements/Mecanique/Biellette/BielletteC1.cc @@ -501,7 +501,7 @@ void BielletteC1::ErreurElement(int type,double& errElemRelative // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void BielletteC1::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de la BielletteC1 @@ -520,7 +520,7 @@ void BielletteC1::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "BielletteC1::Lecture_base_info(ofstream& sort,int cas)" + cout << "BielletteC1::Lecture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -530,7 +530,7 @@ void BielletteC1::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void BielletteC1::Ecriture_base_info(ofstream& sort,const int cas) +void BielletteC1::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de la BielletteC1 @@ -548,7 +548,7 @@ void BielletteC1::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "BielletteC1::Ecriture_base_info(ofstream& sort,int cas)" + cout << "BielletteC1::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -703,7 +703,7 @@ Element* BielletteC1::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, cons // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void BielletteC1::AfficheVarDual(ofstream& sort, Tableau& nom) + void BielletteC1::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element bielette (2 noeuds 1 point d'integration) "; diff --git a/Elements/Mecanique/Biellette/BielletteC1.h b/Elements/Mecanique/Biellette/BielletteC1.h index dec0b36..81e5a96 100644 --- a/Elements/Mecanique/Biellette/BielletteC1.h +++ b/Elements/Mecanique/Biellette/BielletteC1.h @@ -189,7 +189,7 @@ class BielletteC1 : public ElemMeca // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // affichage d'info en fonction de ordre // ordre = "commande" : affichage d'un exemple d'entree pour l'élément @@ -235,11 +235,11 @@ class BielletteC1 : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // METHODES VIRTUELLES: // --------- calculs utils dans le cadre de la recherche du flambement linéaire diff --git a/Elements/Mecanique/Biellette/BielletteQ.cc b/Elements/Mecanique/Biellette/BielletteQ.cc index 71de21e..78df22c 100644 --- a/Elements/Mecanique/Biellette/BielletteQ.cc +++ b/Elements/Mecanique/Biellette/BielletteQ.cc @@ -562,7 +562,7 @@ void BielletteQ::ErreurElement(int type,double& errElemRelative // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void BielletteQ::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de la BielletteQ @@ -593,7 +593,7 @@ void BielletteQ::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "BielletteQ::Lecture_base_info(ofstream& sort,int cas)" + cout << "BielletteQ::Lecture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -603,7 +603,7 @@ void BielletteQ::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void BielletteQ::Ecriture_base_info(ofstream& sort,const int cas) +void BielletteQ::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de la BielletteQ @@ -627,7 +627,7 @@ void BielletteQ::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "BielletteQ::Ecriture_base_info(ofstream& sort,int cas)" + cout << "BielletteQ::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -818,7 +818,7 @@ Element* BielletteQ::Complet_Hourglass(LoiAbstraiteGeneral * loiHourglass, const // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void BielletteQ::AfficheVarDual(ofstream& sort, Tableau& nom) + void BielletteQ::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element bieletteQ (3 noeuds 2 point d'integration) "; diff --git a/Elements/Mecanique/Biellette/BielletteQ.h b/Elements/Mecanique/Biellette/BielletteQ.h index 17a6303..1b7d344 100644 --- a/Elements/Mecanique/Biellette/BielletteQ.h +++ b/Elements/Mecanique/Biellette/BielletteQ.h @@ -191,7 +191,7 @@ class BielletteQ : public ElemMeca // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // affichage d'info en fonction de ordre // ordre = "commande" : affichage d'un exemple d'entree pour l'élément @@ -236,11 +236,11 @@ class BielletteQ : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // METHODES VIRTUELLES: // --------- calculs utils dans le cadre de la recherche du flambement linéaire diff --git a/Elements/Mecanique/Biellette/PoutSimple1.cc b/Elements/Mecanique/Biellette/PoutSimple1.cc index 1db86c4..9d94a53 100644 --- a/Elements/Mecanique/Biellette/PoutSimple1.cc +++ b/Elements/Mecanique/Biellette/PoutSimple1.cc @@ -667,7 +667,7 @@ void PoutSimple1::TversTdt() // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void PoutSimple1::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de la poutre @@ -686,7 +686,7 @@ void PoutSimple1::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "Lecture_base_info(ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) " << " cas= " << cas << endl; Sortie(1); @@ -697,7 +697,7 @@ void PoutSimple1::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void PoutSimple1::Ecriture_base_info(ofstream& sort,const int cas) +void PoutSimple1::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de la poutre @@ -715,7 +715,7 @@ void PoutSimple1::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "PoutSimple1::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "PoutSimple1::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -825,7 +825,7 @@ int PoutSimple1::TestComplet() // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void PoutSimple1::AfficheVarDual(ofstream& sort, Tableau& nom) + void PoutSimple1::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element PoutSimple1 (" << nbNoeud << " noeuds " diff --git a/Elements/Mecanique/Biellette/PoutSimple1.h b/Elements/Mecanique/Biellette/PoutSimple1.h index 5e611ac..0c07475 100644 --- a/Elements/Mecanique/Biellette/PoutSimple1.h +++ b/Elements/Mecanique/Biellette/PoutSimple1.h @@ -198,7 +198,7 @@ class PoutSimple1 : public PiPoCo // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); //============= lecture écriture dans base info ========== @@ -206,11 +206,11 @@ class PoutSimple1 : public PiPoCo // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // définition du nombre maxi de point d'intégration dans l'épaisseur inline int Nb_pt_int_epai() diff --git a/Elements/Mecanique/Biellette/PoutTimo.cc b/Elements/Mecanique/Biellette/PoutTimo.cc index d72b05b..bbc977d 100644 --- a/Elements/Mecanique/Biellette/PoutTimo.cc +++ b/Elements/Mecanique/Biellette/PoutTimo.cc @@ -1 +1 @@ -// FICHIER : PoutTimo.cp // CLASSE : PoutTimo // This file is part of the Herezh++ application. // // The finite element software Herezh++ is dedicated to the field // of mechanics for large transformations of solid structures. // It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600) // INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) . // // Herezh++ is distributed under GPL 3 license ou ultérieure. // // Copyright (C) 1997-2022 Université Bretagne Sud (France) // AUTHOR : Gérard Rio // E-MAIL : gerardrio56@free.fr // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // For more information, please consult: . //#include "Debug.h" #include #include #include "Sortie.h" #include "PoutTimo.h" #include "FrontPointF.h" #include "FrontSegLine.h" //---------------------------------------------------------------- // def des donnees commune a tous les elements // la taille n'est pas defini ici car elle depend de la lecture //---------------------------------------------------------------- PoutTimo::DonneeCommune * PoutTimo::doCo = NULL; int PoutTimo::CalculResidu_t_PoutTimo_met_abstraite = 0; int PoutTimo::Calcul_implicit_PoutTimo_met_abstraite = 0; int PoutTimo::Calcul_VarDualSort = 0; PoutTimo::ConstrucElementpoutTimo PoutTimo::construcElementpoutTimo; // fonction privee // dans cette fonction il ne doit y avoir que les données communes !! void PoutTimo::Def_DonneeCommune() { // interpollation GeomSeg segment(1,2) ; // element geometrique correspondant: 1 pt integ, 2 noeuds // degre de liberte int dim = ParaGlob::Dimension(); DdlElement tab_ddl(2,dim); int posi = Id_nom_ddl("X1") -1; for (int i =1; i<= ParaGlob::Dimension(); i++) {tab_ddl (1,i) = Enum_ddl(i+posi); tab_ddl (2,i) = Enum_ddl(i+posi); } // def metrique // on definit les variables a priori toujours utiles Tableau tab(15); tab(1) = iM0; tab(2) = iMt; tab(3) = iMtdt ; tab(4)=igiB_0;tab(5)=igiB_t;tab(6)=igiB_tdt; tab(7)=igiH_0;tab(8)=igiH_t;tab(9)=igiH_tdt ; tab(10)=igijBB_0;tab(11)=igijBB_t;tab(12)=igijBB_tdt; tab(13)=igijHH_0;tab(14)=igijHH_t;tab(15)=igijHH_tdt ; // dim du pb , nb de vecteur de la base , tableau de ddl et la def de variables Met_biellette metri(ParaGlob::Dimension(),tab_ddl,tab,2) ; // definition de la classe static contenant toute les variables communes aux biellettes doCo = new DonneeCommune(segment,tab_ddl,metri); }; PoutTimo::PoutTimo () : // Constructeur par defaut ElemMeca() { id_interpol=BIE1; // donnees de la classe mere id_geom=POUT; // // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=-1.; tab_noeud.Change_taille(2); // le fait de mettre les pointeurs a null permet // de savoir que l'element n'est pas complet tab_noeud(1) = NULL;tab_noeud(2) = NULL; // definition des donnees communes aux biellettes // a la premiere definition d'une biellette if (doCo == NULL) Def_DonneeCommune(); met = &(doCo->met_biellette); // met est defini dans elemeca // def pointe sur la deformation specifique a l'element def = new Deformation(*met,*this,(doCo->segment).taDphi(),(doCo->segment).taPhi()); //dimensionnement des deformations et contraintes epsBB = NevezTenseurBB (1); sigHH = NevezTenseurHH (1); int nbddl = doCo->tab_ddl.NbDdl(); d_epsBB.Change_taille(nbddl); for (int i=1; i<= nbddl; i++) d_epsBB(i) = NevezTenseurBB (1); }; PoutTimo::PoutTimo (double sect,int num_id): // Constructeur utile si la section de l'element et // le numero de l'element sont connus ElemMeca(num_id,BIE1,POUT) { // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=sect; tab_noeud.Change_taille(2); // le fait de mettre les pointeurs a null permet // de savoir que l'element n'est pas complet tab_noeud(1) = NULL;tab_noeud(2) = NULL; // definition des donnees communes aux biellettes // a la premiere definition d'une biellette if (doCo == NULL) Def_DonneeCommune(); met = &(doCo->met_biellette);// met est defini dans elemeca // def pointe sur la deformation specifique a l'element def = new Deformation(*met,*this,(doCo->segment).taDphi(),(doCo->segment).taPhi()); //dimensionnement des deformations et contraintes epsBB = NevezTenseurBB (1); sigHH = NevezTenseurHH (1); int nbddl = doCo->tab_ddl.NbDdl(); d_epsBB.Change_taille(nbddl); for (int i=1; i<= nbddl; i++) d_epsBB(i) = NevezTenseurBB (1); }; // Constructeur fonction d'un numero d'identification PoutTimo::PoutTimo (int num_id) : ElemMeca(num_id,BIE1,POUT) { // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=-1.; // c-a-d non valide tab_noeud.Change_taille(2); // le fait de mettre les pointeurs a null permet // de savoir que l'element n'est pas complet tab_noeud(1) = NULL;tab_noeud(2) = NULL; // definition des donnees communes aux biellettes // a la premiere definition d'une biellette if (doCo == NULL) Def_DonneeCommune(); met = &(doCo->met_biellette);// met est defini dans elemeca // def pointe sur la deformation specifique a l'element def = new Deformation(*met,*this,(doCo->segment).taDphi(),(doCo->segment).taPhi()); //dimensionnement des deformations et contraintes epsBB = NevezTenseurBB (1); sigHH = NevezTenseurHH (1); int nbddl = doCo->tab_ddl.NbDdl(); d_epsBB.Change_taille(nbddl); for (int i=1; i<= nbddl; i++) d_epsBB(i) = NevezTenseurBB (1); }; PoutTimo::PoutTimo (double sect,int num_id,const Tableau& tab): // Constructeur utile si la section de l'element, le numero de l'element et // le tableau des noeuds sont connus ElemMeca(num_id,tab,BIE1,POUT) { // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=sect; if (tab_noeud.Taille() != 2) { cout << "\n erreur de dimensionnement du tableau de noeud \n"; cout << " PoutTimo::PoutTimo (double sect,int num_id,const Tableau& tab)\n"; Sortie (1); } // definition des donnees communes aux biellettes // a la premiere definition d'une biellette if (doCo == NULL) Def_DonneeCommune(); met = &(doCo->met_biellette);// met est defini dans elemeca // def pointe sur la deformation specifique a l'element def = new Deformation(*met,*this,(doCo->segment).taDphi(),(doCo->segment).taPhi()); //dimensionnement des deformations et contraintes epsBB = NevezTenseurBB (1); sigHH = NevezTenseurHH (1); int nbddl = doCo->tab_ddl.NbDdl(); d_epsBB.Change_taille(nbddl); for (int i=1; i<= nbddl; i++) d_epsBB(i) = NevezTenseurBB (1); // construction du tableau de ddl des noeuds de biellette ConstTabDdl(); }; PoutTimo::PoutTimo (PoutTimo& poutTimo) : ElemMeca (poutTimo) // Constructeur de copie { // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=poutTimo.section; *(epsBB) = *(poutTimo.epsBB); *(sigHH) = *(poutTimo.sigHH); d_epsBB=poutTimo.d_epsBB; for (int i=1; i<= d_epsBB.Taille(); i++) { d_epsBB(i) = NevezTenseurBB(1); *d_epsBB(i) = *(poutTimo.d_epsBB(i)); } *(residu) = *(poutTimo.residu); *(raideur) = *(poutTimo.raideur); *met = *(poutTimo.met); *def = *(poutTimo.def); }; PoutTimo::~PoutTimo () // Destructeur { delete epsBB; delete sigHH; for (int i=1; i<= d_epsBB.Taille(); i++) delete d_epsBB(i); LibereTenseur(); delete def; // la deformation }; // Lecture des donnees de la classe sur fichier void PoutTimo::LectureDonneesParticulieres (UtilLecture * entreePrinc,Tableau * tabMaillageNoeud) { int nb; tab_noeud.Change_taille(2); for (int i=1; i<= 2; i++) { *(entreePrinc->entree) >> nb; tab_noeud(i) = (*tabMaillageNoeud)(nb); } // construction du tableau de ddl des noeuds de biellette ConstTabDdl(); }; // Calcul du residu local Vecteur* PoutTimo::CalculResidu_t () { // dimensionnement de la metrique if( CalculResidu_t_PoutTimo_met_abstraite == 0) { Tableau tab(7); tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t; tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ; doCo->met_biellette.PlusInitVariables(tab) ; CalculResidu_t_PoutTimo_met_abstraite = 1; }; // dimensionnement du residu int nbddl = doCo->tab_ddl.NbDdl(); if ( residu == NULL) residu = new Vecteur(nbddl); // cas du premier passage else for (int i =1; i<= nbddl; i++) // cas des autres passages (*residu)(i) = 0.; // on initialise a zero Vecteur poids =(doCo->segment).taWi(); // poids d'interpolation = 2 poids(1) *= section; Tableau tabSigHH(1); tabSigHH(1) = sigHH; Tableau tabEpsBB(1); tabEpsBB(1) = epsBB; ElemMeca::Cal_explicit ( doCo->tab_ddl,tabEpsBB,d_epsBB,tabSigHH,1,poids); return residu; }; // Calcul du residu local et de la raideur locale, // pour le schema implicite Element::ResRaid PoutTimo::Calcul_implicit () { if( Calcul_implicit_PoutTimo_met_abstraite == 0) { Tableau tab(13); tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igiB_tdt; tab(4) = igijBB_0; tab(5) = igijBB_t;tab(6) = igijBB_tdt; tab(7) = igijHH_tdt; tab(8) = id_giB_tdt; tab(9) = id_gijBB_tdt ;tab(10) = igiH_tdt;tab(11) = id_giH_tdt; tab(12) = id_gijHH_tdt;tab(13) = id_jacobien_tdt; doCo->met_biellette.PlusInitVariables(tab) ; Calcul_implicit_PoutTimo_met_abstraite = 1; }; // dimensionnement du residu int nbddl = doCo->tab_ddl.NbDdl(); if ( residu == NULL) residu = new Vecteur(nbddl); // cas du premier passage else for (int i =1; i<= nbddl; i++) // cas des autres passages (*residu)(i) = 0.; // on initialise a zero // dimensionnement de la raideur if ( raideur == NULL) raideur = new Mat_pleine(nbddl,nbddl); // cas du premier passage else for (int i =1; i<= nbddl; i++) // cas des autres passages for (int j=1; j<= nbddl; j++) // (*raideur)(i,j) = 0.; // on initialise a zero Vecteur poids =(doCo->segment).taWi(); // poids d'interpolation = 2 poids(1) *= section; Tableau tabSigHH(1); tabSigHH(1) = sigHH; Tableau tabEpsBB(1); tabEpsBB(1) = epsBB; ElemMeca::Cal_implicit (doCo->tab_ddl,tabEpsBB, d_epsBB,tabSigHH,1,poids); Element::ResRaid el; el.res = residu; el.raid = raideur; return el; }; // Calcul de la matrice géométrique et initiale ElemMeca::MatGeomInit PoutTimo::MatricesGeometrique_Et_Initiale () { if( Calcul_implicit_PoutTimo_met_abstraite == 0) { Tableau tab(14); tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igiB_tdt; tab(4) = igijBB_0; tab(5) = igijBB_t;tab(6) = igijBB_tdt; tab(7) = igijHH_tdt; tab(8) = id_giB_tdt; tab(9) = id_gijBB_tdt ;tab(10) = igiH_tdt;tab(11) = id_giH_tdt; tab(12) = id_gijHH_tdt;tab(13) = id_jacobien_tdt;tab(14) = id2_gijBB_tdt; doCo->met_biellette.PlusInitVariables(tab) ; Calcul_implicit_PoutTimo_met_abstraite = 1; }; // Par simplicité Mat_pleine & matGeom = doCo->matGeom; Mat_pleine & matInit = doCo->matInit; // mise à zéro de la matrice géométrique matGeom.Initialise(); Vecteur poids =(doCo->segment).taWi(); // poids d'interpolation = 2 poids(1) *= section; Tableau tabSigHH(1); tabSigHH(1) = sigHH; Tableau tabEpsBB(1); tabEpsBB(1) = epsBB; ElemMeca::Cal_matGeom_Init (matGeom,matInit,doCo->tab_ddl,tabEpsBB, d_epsBB, doCo->d2_epsBB,tabSigHH,1,poids); return MatGeomInit(&matGeom,&matInit); } ; // retourne les tableaux de ddl gere par l'element // ce tableau et specifique a l'element DdlElement & PoutTimo::TableauDdl() { return doCo->tab_ddl; }; // liberation de la place pointee void PoutTimo::Libere () {Element::Libere (); // liberation de residu et raideur LibereTenseur() ; // liberation des tenseur intermediaires for (int i=1; i<= d_epsBB.Taille(); i++) // a priori est locale delete d_epsBB(i); }; // acquisition ou modification d'une loi de comportement void PoutTimo::DefLoi (LoiAbstraiteGeneral * NouvelleLoi) { loiComp = (Loi_comp_abstraite *) NouvelleLoi; // verification du type de loi if (loiComp->Dimension() != 1) { cout << "\n Erreur, la loi de comportement a utiliser avec des biellettes"; cout << " doit etre de type 1D, \n ici est de type = " << (NouvelleLoi->Dimension()) << " !!! " << endl; Sortie(1); } // initialisation du stockage particulier, ici 1 pt d'integ tabSaveDon(1) = loiComp->Initialise(); }; // test si l'element est complet int PoutTimo::TestComplet() { int res = ElemMeca::TestComplet(); // test dans la fonction mere if ( section == -1) { cout << "\n la section de la biellette n'est pas defini \n"; res = 0; } if ( tab_noeud(1) == NULL) { cout << "\n les noeuds de la biellette ne sont pas defini \n"; res = 0; } else { int testi =1; int posi = Id_nom_ddl("X1") -1; for (int i =1; i<= ParaGlob::Dimension(); i++) for (int j=1;j<=2;j++) if(!(tab_noeud(j)->Existe_ici(Enum_ddl(posi+i)))) testi = 0; if(testi == 0) { cout << "\n les ddls X1,X2 etc des noeuds de la biellette ne sont pas defini \n"; cout << " \n utilisez PoutTimo::ConstTabDdl() pour completer " ; res = 0; } } return res; }; // ajout du tableau de ddl des noeuds de biellette void PoutTimo::ConstTabDdl() { Tableau ta(ParaGlob::Dimension()); int posi = Id_nom_ddl("X1") -1; for (int i =1; i<= ParaGlob::Dimension(); i++) {Ddl inter((Enum_ddl(i+posi)),0.,false); ta(i) = inter; } // attribution des ddls aux noeuds tab_noeud(1)->PlusTabDdl(ta); tab_noeud(2)->PlusTabDdl(ta); }; // procesure permettant de completer l'element apres // sa creation avec les donnees du bloc transmis // peut etre appeler plusieurs fois Element* PoutTimo::Complete(BlocGen & bloc,LesFonctions_nD* lesFonctionsnD) { if (bloc.Nom(1) == "sections") { section = bloc.Val(1); return this; } else return ElemMeca::Complete_ElemMeca(bloc,lesFonctionsnD); //return NULL; }; // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables void PoutTimo::AfficheVarDual(ofstream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element poutTimo (2 noeuds 1 point d'integration) "; sort << "\n******************************************************************"; // appel de la procedure de elem meca Tableau tabSigHH(1); tabSigHH(1) = sigHH; Tableau tabEpsBB(1); tabEpsBB(1) = epsBB; if ((Calcul_VarDualSort == 0) && (Calcul_implicit_PoutTimo_met_abstraite != 0)) { VarDualSort(sort,nom,tabSigHH,tabEpsBB,1,1); Calcul_VarDualSort = 1; } else if ((Calcul_VarDualSort == 1) && (Calcul_implicit_PoutTimo_met_abstraite != 0)) VarDualSort(sort,nom,tabSigHH,tabEpsBB,1,11); else if ((Calcul_VarDualSort == 0) && (CalculResidu_t_PoutTimo_met_abstraite != 0)) { VarDualSort(sort,nom,tabSigHH,tabEpsBB,1,2); Calcul_VarDualSort = 1; } else if ((Calcul_VarDualSort == 1) && (CalculResidu_t_PoutTimo_met_abstraite != 0)) VarDualSort(sort,nom,tabSigHH,tabEpsBB,1,12); // sinon on ne fait rien }; // Calcul des frontieres de l'element // creation des elements frontieres et retour du tableau de ces elements Tableau & PoutTimo::Frontiere() { int cas = 6; // on veut des lignes et des points return Frontiere_elemeca(cas,force); // { // dimensionnement des tableaux intermediaires // Tableau tab(1); // les noeuds des points frontieres // DdlElement ddelem(1); // les ddlelements des points frontieres // int tail; // if (ParaGlob::Dimension() <= 2) // tail = 2; // deux points // else if (ParaGlob::Dimension() == 3) // tail = 3; // deux points et le segment lui-meme // #ifdef MISE_AU_POINT // else // { cout << "\n erreur de dimension dans PoutTimo, dim = " << ParaGlob::Dimension(); // cout << "\n alors que l'on doit avoir 1 ou 2 ou 3 !! " << endl; // Sortie (1); // } // #endif // tabb.Change_taille(tail); // // premier point // tab(1) = tab_noeud(1); // ddelem(1) = doCo->tab_ddl(1); // tabb(1) = new FrontPointF (tab,ddelem); // // second point // tab(1) = tab_noeud(2); // ddelem(1) = doCo->tab_ddl(2); // tabb(2) = new FrontPointF (tab,ddelem); // // 3 ieme cote eventuelle // if (tail == 3) // tabb(3) = new FrontSegLine(tab_noeud,doCo->tab_ddl); // // return tabb; }; \ No newline at end of file +// FICHIER : PoutTimo.cp // CLASSE : PoutTimo // This file is part of the Herezh++ application. // // The finite element software Herezh++ is dedicated to the field // of mechanics for large transformations of solid structures. // It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600) // INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) . // // Herezh++ is distributed under GPL 3 license ou ultérieure. // // Copyright (C) 1997-2022 Université Bretagne Sud (France) // AUTHOR : Gérard Rio // E-MAIL : gerardrio56@free.fr // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty // of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . // // For more information, please consult: . //#include "Debug.h" #include #include #include "Sortie.h" #include "PoutTimo.h" #include "FrontPointF.h" #include "FrontSegLine.h" //---------------------------------------------------------------- // def des donnees commune a tous les elements // la taille n'est pas defini ici car elle depend de la lecture //---------------------------------------------------------------- PoutTimo::DonneeCommune * PoutTimo::doCo = NULL; int PoutTimo::CalculResidu_t_PoutTimo_met_abstraite = 0; int PoutTimo::Calcul_implicit_PoutTimo_met_abstraite = 0; int PoutTimo::Calcul_VarDualSort = 0; PoutTimo::ConstrucElementpoutTimo PoutTimo::construcElementpoutTimo; // fonction privee // dans cette fonction il ne doit y avoir que les données communes !! void PoutTimo::Def_DonneeCommune() { // interpollation GeomSeg segment(1,2) ; // element geometrique correspondant: 1 pt integ, 2 noeuds // degre de liberte int dim = ParaGlob::Dimension(); DdlElement tab_ddl(2,dim); int posi = Id_nom_ddl("X1") -1; for (int i =1; i<= ParaGlob::Dimension(); i++) {tab_ddl (1,i) = Enum_ddl(i+posi); tab_ddl (2,i) = Enum_ddl(i+posi); } // def metrique // on definit les variables a priori toujours utiles Tableau tab(15); tab(1) = iM0; tab(2) = iMt; tab(3) = iMtdt ; tab(4)=igiB_0;tab(5)=igiB_t;tab(6)=igiB_tdt; tab(7)=igiH_0;tab(8)=igiH_t;tab(9)=igiH_tdt ; tab(10)=igijBB_0;tab(11)=igijBB_t;tab(12)=igijBB_tdt; tab(13)=igijHH_0;tab(14)=igijHH_t;tab(15)=igijHH_tdt ; // dim du pb , nb de vecteur de la base , tableau de ddl et la def de variables Met_biellette metri(ParaGlob::Dimension(),tab_ddl,tab,2) ; // definition de la classe static contenant toute les variables communes aux biellettes doCo = new DonneeCommune(segment,tab_ddl,metri); }; PoutTimo::PoutTimo () : // Constructeur par defaut ElemMeca() { id_interpol=BIE1; // donnees de la classe mere id_geom=POUT; // // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=-1.; tab_noeud.Change_taille(2); // le fait de mettre les pointeurs a null permet // de savoir que l'element n'est pas complet tab_noeud(1) = NULL;tab_noeud(2) = NULL; // definition des donnees communes aux biellettes // a la premiere definition d'une biellette if (doCo == NULL) Def_DonneeCommune(); met = &(doCo->met_biellette); // met est defini dans elemeca // def pointe sur la deformation specifique a l'element def = new Deformation(*met,*this,(doCo->segment).taDphi(),(doCo->segment).taPhi()); //dimensionnement des deformations et contraintes epsBB = NevezTenseurBB (1); sigHH = NevezTenseurHH (1); int nbddl = doCo->tab_ddl.NbDdl(); d_epsBB.Change_taille(nbddl); for (int i=1; i<= nbddl; i++) d_epsBB(i) = NevezTenseurBB (1); }; PoutTimo::PoutTimo (double sect,int num_id): // Constructeur utile si la section de l'element et // le numero de l'element sont connus ElemMeca(num_id,BIE1,POUT) { // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=sect; tab_noeud.Change_taille(2); // le fait de mettre les pointeurs a null permet // de savoir que l'element n'est pas complet tab_noeud(1) = NULL;tab_noeud(2) = NULL; // definition des donnees communes aux biellettes // a la premiere definition d'une biellette if (doCo == NULL) Def_DonneeCommune(); met = &(doCo->met_biellette);// met est defini dans elemeca // def pointe sur la deformation specifique a l'element def = new Deformation(*met,*this,(doCo->segment).taDphi(),(doCo->segment).taPhi()); //dimensionnement des deformations et contraintes epsBB = NevezTenseurBB (1); sigHH = NevezTenseurHH (1); int nbddl = doCo->tab_ddl.NbDdl(); d_epsBB.Change_taille(nbddl); for (int i=1; i<= nbddl; i++) d_epsBB(i) = NevezTenseurBB (1); }; // Constructeur fonction d'un numero d'identification PoutTimo::PoutTimo (int num_id) : ElemMeca(num_id,BIE1,POUT) { // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=-1.; // c-a-d non valide tab_noeud.Change_taille(2); // le fait de mettre les pointeurs a null permet // de savoir que l'element n'est pas complet tab_noeud(1) = NULL;tab_noeud(2) = NULL; // definition des donnees communes aux biellettes // a la premiere definition d'une biellette if (doCo == NULL) Def_DonneeCommune(); met = &(doCo->met_biellette);// met est defini dans elemeca // def pointe sur la deformation specifique a l'element def = new Deformation(*met,*this,(doCo->segment).taDphi(),(doCo->segment).taPhi()); //dimensionnement des deformations et contraintes epsBB = NevezTenseurBB (1); sigHH = NevezTenseurHH (1); int nbddl = doCo->tab_ddl.NbDdl(); d_epsBB.Change_taille(nbddl); for (int i=1; i<= nbddl; i++) d_epsBB(i) = NevezTenseurBB (1); }; PoutTimo::PoutTimo (double sect,int num_id,const Tableau& tab): // Constructeur utile si la section de l'element, le numero de l'element et // le tableau des noeuds sont connus ElemMeca(num_id,tab,BIE1,POUT) { // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=sect; if (tab_noeud.Taille() != 2) { cout << "\n erreur de dimensionnement du tableau de noeud \n"; cout << " PoutTimo::PoutTimo (double sect,int num_id,const Tableau& tab)\n"; Sortie (1); } // definition des donnees communes aux biellettes // a la premiere definition d'une biellette if (doCo == NULL) Def_DonneeCommune(); met = &(doCo->met_biellette);// met est defini dans elemeca // def pointe sur la deformation specifique a l'element def = new Deformation(*met,*this,(doCo->segment).taDphi(),(doCo->segment).taPhi()); //dimensionnement des deformations et contraintes epsBB = NevezTenseurBB (1); sigHH = NevezTenseurHH (1); int nbddl = doCo->tab_ddl.NbDdl(); d_epsBB.Change_taille(nbddl); for (int i=1; i<= nbddl; i++) d_epsBB(i) = NevezTenseurBB (1); // construction du tableau de ddl des noeuds de biellette ConstTabDdl(); }; PoutTimo::PoutTimo (PoutTimo& poutTimo) : ElemMeca (poutTimo) // Constructeur de copie { // stockage des donnees particulieres de la loi de comportement au point d'integ tabSaveDon.Change_taille(1); section=poutTimo.section; *(epsBB) = *(poutTimo.epsBB); *(sigHH) = *(poutTimo.sigHH); d_epsBB=poutTimo.d_epsBB; for (int i=1; i<= d_epsBB.Taille(); i++) { d_epsBB(i) = NevezTenseurBB(1); *d_epsBB(i) = *(poutTimo.d_epsBB(i)); } *(residu) = *(poutTimo.residu); *(raideur) = *(poutTimo.raideur); *met = *(poutTimo.met); *def = *(poutTimo.def); }; PoutTimo::~PoutTimo () // Destructeur { delete epsBB; delete sigHH; for (int i=1; i<= d_epsBB.Taille(); i++) delete d_epsBB(i); LibereTenseur(); delete def; // la deformation }; // Lecture des donnees de la classe sur fichier void PoutTimo::LectureDonneesParticulieres (UtilLecture * entreePrinc,Tableau * tabMaillageNoeud) { int nb; tab_noeud.Change_taille(2); for (int i=1; i<= 2; i++) { *(entreePrinc->entree) >> nb; tab_noeud(i) = (*tabMaillageNoeud)(nb); } // construction du tableau de ddl des noeuds de biellette ConstTabDdl(); }; // Calcul du residu local Vecteur* PoutTimo::CalculResidu_t () { // dimensionnement de la metrique if( CalculResidu_t_PoutTimo_met_abstraite == 0) { Tableau tab(7); tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igijBB_0;tab(4) = igijBB_t; tab(5) = igijHH_t; tab(6) = id_giB_t; tab(7) = id_gijBB_t ; doCo->met_biellette.PlusInitVariables(tab) ; CalculResidu_t_PoutTimo_met_abstraite = 1; }; // dimensionnement du residu int nbddl = doCo->tab_ddl.NbDdl(); if ( residu == NULL) residu = new Vecteur(nbddl); // cas du premier passage else for (int i =1; i<= nbddl; i++) // cas des autres passages (*residu)(i) = 0.; // on initialise a zero Vecteur poids =(doCo->segment).taWi(); // poids d'interpolation = 2 poids(1) *= section; Tableau tabSigHH(1); tabSigHH(1) = sigHH; Tableau tabEpsBB(1); tabEpsBB(1) = epsBB; ElemMeca::Cal_explicit ( doCo->tab_ddl,tabEpsBB,d_epsBB,tabSigHH,1,poids); return residu; }; // Calcul du residu local et de la raideur locale, // pour le schema implicite Element::ResRaid PoutTimo::Calcul_implicit () { if( Calcul_implicit_PoutTimo_met_abstraite == 0) { Tableau tab(13); tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igiB_tdt; tab(4) = igijBB_0; tab(5) = igijBB_t;tab(6) = igijBB_tdt; tab(7) = igijHH_tdt; tab(8) = id_giB_tdt; tab(9) = id_gijBB_tdt ;tab(10) = igiH_tdt;tab(11) = id_giH_tdt; tab(12) = id_gijHH_tdt;tab(13) = id_jacobien_tdt; doCo->met_biellette.PlusInitVariables(tab) ; Calcul_implicit_PoutTimo_met_abstraite = 1; }; // dimensionnement du residu int nbddl = doCo->tab_ddl.NbDdl(); if ( residu == NULL) residu = new Vecteur(nbddl); // cas du premier passage else for (int i =1; i<= nbddl; i++) // cas des autres passages (*residu)(i) = 0.; // on initialise a zero // dimensionnement de la raideur if ( raideur == NULL) raideur = new Mat_pleine(nbddl,nbddl); // cas du premier passage else for (int i =1; i<= nbddl; i++) // cas des autres passages for (int j=1; j<= nbddl; j++) // (*raideur)(i,j) = 0.; // on initialise a zero Vecteur poids =(doCo->segment).taWi(); // poids d'interpolation = 2 poids(1) *= section; Tableau tabSigHH(1); tabSigHH(1) = sigHH; Tableau tabEpsBB(1); tabEpsBB(1) = epsBB; ElemMeca::Cal_implicit (doCo->tab_ddl,tabEpsBB, d_epsBB,tabSigHH,1,poids); Element::ResRaid el; el.res = residu; el.raid = raideur; return el; }; // Calcul de la matrice géométrique et initiale ElemMeca::MatGeomInit PoutTimo::MatricesGeometrique_Et_Initiale () { if( Calcul_implicit_PoutTimo_met_abstraite == 0) { Tableau tab(14); tab(1) = igiB_0; tab(2) = igiB_t; tab(3) = igiB_tdt; tab(4) = igijBB_0; tab(5) = igijBB_t;tab(6) = igijBB_tdt; tab(7) = igijHH_tdt; tab(8) = id_giB_tdt; tab(9) = id_gijBB_tdt ;tab(10) = igiH_tdt;tab(11) = id_giH_tdt; tab(12) = id_gijHH_tdt;tab(13) = id_jacobien_tdt;tab(14) = id2_gijBB_tdt; doCo->met_biellette.PlusInitVariables(tab) ; Calcul_implicit_PoutTimo_met_abstraite = 1; }; // Par simplicité Mat_pleine & matGeom = doCo->matGeom; Mat_pleine & matInit = doCo->matInit; // mise à zéro de la matrice géométrique matGeom.Initialise(); Vecteur poids =(doCo->segment).taWi(); // poids d'interpolation = 2 poids(1) *= section; Tableau tabSigHH(1); tabSigHH(1) = sigHH; Tableau tabEpsBB(1); tabEpsBB(1) = epsBB; ElemMeca::Cal_matGeom_Init (matGeom,matInit,doCo->tab_ddl,tabEpsBB, d_epsBB, doCo->d2_epsBB,tabSigHH,1,poids); return MatGeomInit(&matGeom,&matInit); } ; // retourne les tableaux de ddl gere par l'element // ce tableau et specifique a l'element DdlElement & PoutTimo::TableauDdl() { return doCo->tab_ddl; }; // liberation de la place pointee void PoutTimo::Libere () {Element::Libere (); // liberation de residu et raideur LibereTenseur() ; // liberation des tenseur intermediaires for (int i=1; i<= d_epsBB.Taille(); i++) // a priori est locale delete d_epsBB(i); }; // acquisition ou modification d'une loi de comportement void PoutTimo::DefLoi (LoiAbstraiteGeneral * NouvelleLoi) { loiComp = (Loi_comp_abstraite *) NouvelleLoi; // verification du type de loi if (loiComp->Dimension() != 1) { cout << "\n Erreur, la loi de comportement a utiliser avec des biellettes"; cout << " doit etre de type 1D, \n ici est de type = " << (NouvelleLoi->Dimension()) << " !!! " << endl; Sortie(1); } // initialisation du stockage particulier, ici 1 pt d'integ tabSaveDon(1) = loiComp->Initialise(); }; // test si l'element est complet int PoutTimo::TestComplet() { int res = ElemMeca::TestComplet(); // test dans la fonction mere if ( section == -1) { cout << "\n la section de la biellette n'est pas defini \n"; res = 0; } if ( tab_noeud(1) == NULL) { cout << "\n les noeuds de la biellette ne sont pas defini \n"; res = 0; } else { int testi =1; int posi = Id_nom_ddl("X1") -1; for (int i =1; i<= ParaGlob::Dimension(); i++) for (int j=1;j<=2;j++) if(!(tab_noeud(j)->Existe_ici(Enum_ddl(posi+i)))) testi = 0; if(testi == 0) { cout << "\n les ddls X1,X2 etc des noeuds de la biellette ne sont pas defini \n"; cout << " \n utilisez PoutTimo::ConstTabDdl() pour completer " ; res = 0; } } return res; }; // ajout du tableau de ddl des noeuds de biellette void PoutTimo::ConstTabDdl() { Tableau ta(ParaGlob::Dimension()); int posi = Id_nom_ddl("X1") -1; for (int i =1; i<= ParaGlob::Dimension(); i++) {Ddl inter((Enum_ddl(i+posi)),0.,false); ta(i) = inter; } // attribution des ddls aux noeuds tab_noeud(1)->PlusTabDdl(ta); tab_noeud(2)->PlusTabDdl(ta); }; // procesure permettant de completer l'element apres // sa creation avec les donnees du bloc transmis // peut etre appeler plusieurs fois Element* PoutTimo::Complete(BlocGen & bloc,LesFonctions_nD* lesFonctionsnD) { if (bloc.Nom(1) == "sections") { section = bloc.Val(1); return this; } else return ElemMeca::Complete_ElemMeca(bloc,lesFonctionsnD); //return NULL; }; // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables void PoutTimo::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element poutTimo (2 noeuds 1 point d'integration) "; sort << "\n******************************************************************"; // appel de la procedure de elem meca Tableau tabSigHH(1); tabSigHH(1) = sigHH; Tableau tabEpsBB(1); tabEpsBB(1) = epsBB; if ((Calcul_VarDualSort == 0) && (Calcul_implicit_PoutTimo_met_abstraite != 0)) { VarDualSort(sort,nom,tabSigHH,tabEpsBB,1,1); Calcul_VarDualSort = 1; } else if ((Calcul_VarDualSort == 1) && (Calcul_implicit_PoutTimo_met_abstraite != 0)) VarDualSort(sort,nom,tabSigHH,tabEpsBB,1,11); else if ((Calcul_VarDualSort == 0) && (CalculResidu_t_PoutTimo_met_abstraite != 0)) { VarDualSort(sort,nom,tabSigHH,tabEpsBB,1,2); Calcul_VarDualSort = 1; } else if ((Calcul_VarDualSort == 1) && (CalculResidu_t_PoutTimo_met_abstraite != 0)) VarDualSort(sort,nom,tabSigHH,tabEpsBB,1,12); // sinon on ne fait rien }; // Calcul des frontieres de l'element // creation des elements frontieres et retour du tableau de ces elements Tableau & PoutTimo::Frontiere() { int cas = 6; // on veut des lignes et des points return Frontiere_elemeca(cas,force); // { // dimensionnement des tableaux intermediaires // Tableau tab(1); // les noeuds des points frontieres // DdlElement ddelem(1); // les ddlelements des points frontieres // int tail; // if (ParaGlob::Dimension() <= 2) // tail = 2; // deux points // else if (ParaGlob::Dimension() == 3) // tail = 3; // deux points et le segment lui-meme // #ifdef MISE_AU_POINT // else // { cout << "\n erreur de dimension dans PoutTimo, dim = " << ParaGlob::Dimension(); // cout << "\n alors que l'on doit avoir 1 ou 2 ou 3 !! " << endl; // Sortie (1); // } // #endif // tabb.Change_taille(tail); // // premier point // tab(1) = tab_noeud(1); // ddelem(1) = doCo->tab_ddl(1); // tabb(1) = new FrontPointF (tab,ddelem); // // second point // tab(1) = tab_noeud(2); // ddelem(1) = doCo->tab_ddl(2); // tabb(2) = new FrontPointF (tab,ddelem); // // 3 ieme cote eventuelle // if (tail == 3) // tabb(3) = new FrontSegLine(tab_noeud,doCo->tab_ddl); // // return tabb; }; \ No newline at end of file diff --git a/Elements/Mecanique/Biellette/PoutTimo.h b/Elements/Mecanique/Biellette/PoutTimo.h index 3c23698..d4cf77b 100644 --- a/Elements/Mecanique/Biellette/PoutTimo.h +++ b/Elements/Mecanique/Biellette/PoutTimo.h @@ -158,7 +158,7 @@ class PoutTimo : public ElemMeca // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // Calcul des frontieres de l'element // creation des elements frontieres et retour du tableau de ces elements diff --git a/Elements/Mecanique/Deformation_gene/Deformation.h b/Elements/Mecanique/Deformation_gene/Deformation.h index 1d00bc3..aa06c89 100644 --- a/Elements/Mecanique/Deformation_gene/Deformation.h +++ b/Elements/Mecanique/Deformation_gene/Deformation.h @@ -164,17 +164,17 @@ class Deformation // affichage des infos virtual void Affiche(); - // idem sur un ofstream - virtual void Affiche(ofstream& sort); + // idem sur un ostream + virtual void Affiche(ostream& sort); //============= lecture écriture dans base info ========== // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info (ifstream& ent,const int cas); + virtual void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas); + virtual void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif, ou l'inverse virtual void TdtversT() {meti_t = meti_tdt;(*D_BB_t)=(*D_BB_tdt);}; @@ -208,7 +208,7 @@ class Deformation virtual SaveDefResul * New_et_Initialise() {return (new SaveDefResul(*metrique));}; // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) - virtual void AfficheDataSpecif(ofstream& sort,SaveDefResul * a) const {a->Affiche(sort);}; + virtual void AfficheDataSpecif(ostream& sort,SaveDefResul * a) const {a->Affiche(sort);}; // met à jour les données spécifiques du point considéré void Mise_a_jour_data_specif(Deformation::SaveDefResul* don) {saveDefResul=don;}; diff --git a/Elements/Mecanique/Deformation_gene/DeformationSfe1_stockage.cc b/Elements/Mecanique/Deformation_gene/DeformationSfe1_stockage.cc index b91e253..5af7862 100644 --- a/Elements/Mecanique/Deformation_gene/DeformationSfe1_stockage.cc +++ b/Elements/Mecanique/Deformation_gene/DeformationSfe1_stockage.cc @@ -90,8 +90,8 @@ void DeformationSfe1::SaveDefResulSfe1::Affiche() cout << " meti_a_tdt ";meti_a_tdt.Affiche(); cout <<" "; }; - // idem sur un ofstream -void DeformationSfe1::SaveDefResulSfe1::Affiche(ofstream& sort) + // idem sur un ostream +void DeformationSfe1::SaveDefResulSfe1::Affiche(ostream& sort) {// les variables de la classe mère this->Deformation::SaveDefResul::Affiche(sort); // puis les variables propres @@ -103,7 +103,7 @@ void DeformationSfe1::SaveDefResulSfe1::Affiche(ofstream& sort) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (ifstream& ent,const int cas) +void DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (istream& ent,const int cas) {// lecture de l'entête string nom; // lecture des données @@ -139,7 +139,7 @@ void DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (ifstream& ent,const i // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void DeformationSfe1::SaveDefResulSfe1::Ecriture_base_info(ofstream& sort,const int cas) +void DeformationSfe1::SaveDefResulSfe1::Ecriture_base_info(ostream& sort,const int cas) {// on ne sauvegarde que ce qui est à 0 et à t, ce qui est à tdt est considéré une zone de travail // les variables de la classe mère this->Deformation::SaveDefResul::Ecriture_base_info(sort,cas); diff --git a/Elements/Mecanique/Deformation_gene/Deformation_stockage.cc b/Elements/Mecanique/Deformation_gene/Deformation_stockage.cc index aab758a..69dd374 100644 --- a/Elements/Mecanique/Deformation_gene/Deformation_stockage.cc +++ b/Elements/Mecanique/Deformation_gene/Deformation_stockage.cc @@ -179,8 +179,8 @@ void Deformation::SaveDefResul::Affiche() cout << " meti_tdt ";meti_tdt.Affiche(); cout <<" "; cout << " D_BB_t= ";D_BB_t->Ecriture(cout); cout << " D_BB_tdt= ";D_BB_tdt->Ecriture(cout); cout <<" ";}; - // idem sur un ofstream -void Deformation::SaveDefResul::Affiche(ofstream& sort) + // idem sur un ostream +void Deformation::SaveDefResul::Affiche(ostream& sort) {sort << "\n meti_00: " << meti_00 << " meti_t " << meti_t << " meti_tdt " << meti_tdt <<" "; sort << " D_BB_t= ";D_BB_t->Ecriture(sort); sort << " D_BB_tdt= ";D_BB_tdt->Ecriture(sort); @@ -190,7 +190,7 @@ void Deformation::SaveDefResul::Affiche(ofstream& sort) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Deformation::SaveDefResul::Lecture_base_info (ifstream& ent,const int cas) +void Deformation::SaveDefResul::Lecture_base_info (istream& ent,const int cas) { // lecture de l'entête string nom; // lecture des données @@ -225,7 +225,7 @@ void Deformation::SaveDefResul::Lecture_base_info (ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Deformation::SaveDefResul::Ecriture_base_info(ofstream& sort,const int cas) +void Deformation::SaveDefResul::Ecriture_base_info(ostream& sort,const int cas) { // on ne sauvegarde que ce qui est à 0 et à t, ce qui est à tdt est considéré une zone de travail switch (cas) { case 1 : diff --git a/Elements/Mecanique/ElemMeca.cc b/Elements/Mecanique/ElemMeca.cc index 4084402..cc16a58 100644 --- a/Elements/Mecanique/ElemMeca.cc +++ b/Elements/Mecanique/ElemMeca.cc @@ -173,7 +173,7 @@ void ElemMeca::StabMembBiel::TversTdt() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void ElemMeca::StabMembBiel::Lecture_bas_inf(ifstream& ent,const int cas) +void ElemMeca::StabMembBiel::Lecture_bas_inf(istream& ent,const int cas) {string toto,nom; switch (cas) { case 1 : // ------- on récupère tout ------------------------- @@ -228,7 +228,7 @@ void ElemMeca::StabMembBiel::Lecture_bas_inf(ifstream& ent,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "ElemMeca::StabMembBiel::Lecture_bas_inf(ifstream& ent,const int cas)" + cout << "ElemMeca::StabMembBiel::Lecture_bas_inf(istream& ent,const int cas)" << " cas= " << cas << endl; Sortie(1); }; @@ -239,7 +239,7 @@ void ElemMeca::StabMembBiel::Lecture_bas_inf(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void ElemMeca::StabMembBiel::Ecriture_bas_inf(ofstream& sort,const int cas) +void ElemMeca::StabMembBiel::Ecriture_bas_inf(ostream& sort,const int cas) {switch (cas) { case 1 : // ------- on sauvegarde tout ------------------------- { sort << " "<Ecriture_bas_inf(sort,cas); + pt_StabMembBiel->Ecriture_bas_inf(sort,cas); }; break; } @@ -813,7 +813,7 @@ void ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "ElemMeca::Ecriture_bas_inf(ofstream& sort,const int cas)" + cout << "ElemMeca::Ecriture_bas_inf(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); }; diff --git a/Elements/Mecanique/ElemMeca4.cc b/Elements/Mecanique/ElemMeca4.cc index 1a99826..a814546 100644 --- a/Elements/Mecanique/ElemMeca4.cc +++ b/Elements/Mecanique/ElemMeca4.cc @@ -43,7 +43,7 @@ // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void ElemMeca::VarDualSort(ofstream& sort, Tableau& nom,int ,int cas) +void ElemMeca::VarDualSort(ostream& sort, Tableau& nom,int ,int cas) { if ((cas == 1) || (cas == 2)) { // cas d'une premiere initialisation Tableau tab(5); @@ -273,7 +273,7 @@ void ElemMeca::VarDualSort(ofstream& sort, Tableau& nom,int ,int cas) // liberation des tenseurs intermediaires LibereTenseur(); }; -void ElemMeca::AffDefCont(ofstream& sort,Loi_comp_abstraite::SaveResul * sDon, +void ElemMeca::AffDefCont(ostream& sort,Loi_comp_abstraite::SaveResul * sDon, TenseurBB& eps0BB,TenseurBB& epsBB,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB, TenseurHH& sigHH, TenseurHB& epsHB,TenseurHB& sigHB, @@ -299,7 +299,7 @@ void ElemMeca::AffDefCont(ofstream& sort,Loi_comp_abstraite::SaveResul * sDon, } } }; -void ElemMeca::AffDefCont1D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon, +void ElemMeca::AffDefCont1D(ostream& sort,Loi_comp_abstraite::SaveResul * saveDon, TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB, TenseurHH& sigHH, TenseurHB& epsHB,TenseurHB& sigHB, @@ -376,7 +376,7 @@ void ElemMeca::AffDefCont1D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveD }; -void ElemMeca::AffDefCont2D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon, +void ElemMeca::AffDefCont2D(ostream& sort,Loi_comp_abstraite::SaveResul * saveDon, TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB, TenseurHH& sigHH, TenseurHB& epsHB,TenseurHB& sigHB, @@ -477,7 +477,7 @@ void ElemMeca::AffDefCont2D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveD } }; -void ElemMeca::AffDefCont3D(ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon, +void ElemMeca::AffDefCont3D(ostream& sort,Loi_comp_abstraite::SaveResul * saveDon, TenseurBB& eps0BB,TenseurBB& ,TenseurBB& DepsBB,TenseurBB& DeltaEpsBB, TenseurHH& sigHH, TenseurHB& epsHB,TenseurHB& sigHB, diff --git a/Elements/Mecanique/ElemMecaGene.h b/Elements/Mecanique/ElemMecaGene.h old mode 100755 new mode 100644 index 67ee90e..39fb4d8 --- a/Elements/Mecanique/ElemMecaGene.h +++ b/Elements/Mecanique/ElemMecaGene.h @@ -105,35 +105,35 @@ pour l'instant en essai pour une classe générale au dessus du solide et des fl // cas = 2 -> premier passage pour de l'explicit // cas = 11 -> passage autre que le premier pour de l'implicit // cas = 12 -> passage autre que le premier pour de l'explicit - void VarDualSort(ofstream& sort, Tableau& nom, + void VarDualSort(ostream& sort, Tableau& nom, Tableau & tabSigHH,Tableau & tabEpsBB, int nbint,int cas); // utilitaires de VarDualSort // affiche en fonction d'indic les differentes variables et appel // AffDefContiD en fonction de la dimension i // - void AffDefCont( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon, + void AffDefCont( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon, TenseurBB& eps0BB,TenseurBB& epsBB, TenseurHH& sigHH, TenseurHB& epsHB,TenseurHB& sigHB, Vecteur& valPropreEps,Vecteur& valPropreSig, int indic); // cas 1D - void AffDefCont1D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon, + void AffDefCont1D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon, TenseurBB& eps0BB,TenseurBB& epsBB, TenseurHH& sigHH, TenseurHB& epsHB,TenseurHB& sigHB, Vecteur& valPropreEps,Vecteur& valPropreSig, int indic); // cas 2D - void AffDefCont2D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon, + void AffDefCont2D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon, TenseurBB& eps0BB,TenseurBB& epsBB, TenseurHH& sigHH, TenseurHB& epsHB,TenseurHB& sigHB, Vecteur& valPropreEps,Vecteur& valPropreSig, int indic); // cas 3D - void AffDefCont3D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon, + void AffDefCont3D( ostream& sort,Loi_comp_abstraite::SaveResul * saveDon, TenseurBB& eps0BB,TenseurBB& epsBB, TenseurHH& sigHH, TenseurHB& epsHB,TenseurHB& sigHB, diff --git a/Elements/Mecanique/ElemPoint/ElemPoint.cc b/Elements/Mecanique/ElemPoint/ElemPoint.cc index 066086e..81fac87 100644 --- a/Elements/Mecanique/ElemPoint/ElemPoint.cc +++ b/Elements/Mecanique/ElemPoint/ElemPoint.cc @@ -676,7 +676,7 @@ void ElemPoint::ErreurElement(int type,double& errElemRelative // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void ElemPoint::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) { // tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de la ElemPoint @@ -708,7 +708,7 @@ void ElemPoint::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "ElemPoint::Lecture_base_info(ofstream& sort,int cas)" + cout << "ElemPoint::Lecture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); }; @@ -718,7 +718,7 @@ void ElemPoint::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void ElemPoint::Ecriture_base_info(ofstream& sort,const int cas) +void ElemPoint::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de la ElemPoint @@ -740,7 +740,7 @@ void ElemPoint::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "ElemPoint::Ecriture_base_info(ofstream& sort,int cas)" + cout << "ElemPoint::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); }; @@ -886,7 +886,7 @@ bool ElemPoint::ContraintesAbsolues(Tableau & tabSig) // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void ElemPoint::AfficheVarDual(ofstream& sort, Tableau& nom) + void ElemPoint::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element bielette (2 noeuds 1 point d'integration) "; diff --git a/Elements/Mecanique/ElemPoint/ElemPoint.h b/Elements/Mecanique/ElemPoint/ElemPoint.h index 862cbad..abbfdfb 100644 --- a/Elements/Mecanique/ElemPoint/ElemPoint.h +++ b/Elements/Mecanique/ElemPoint/ElemPoint.h @@ -184,7 +184,7 @@ class ElemPoint : public ElemMeca // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // affichage d'info en fonction de ordre // ordre = "commande" : affichage d'un exemple d'entree pour l'élément @@ -266,11 +266,11 @@ class ElemPoint : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // METHODES VIRTUELLES: // --------- calculs utils dans le cadre de la recherche du flambement linéaire diff --git a/Elements/Mecanique/ElemPoint/UmatAbaqus.cc b/Elements/Mecanique/ElemPoint/UmatAbaqus.cc index a826ef4..2117bc0 100644 --- a/Elements/Mecanique/ElemPoint/UmatAbaqus.cc +++ b/Elements/Mecanique/ElemPoint/UmatAbaqus.cc @@ -690,7 +690,7 @@ void UmatAbaqus::Transfert_Umat_ptInteg_tdt(PtIntegMecaInterne& ptIntegMeca) // affichage en fonction d'un niveau // niveau > 0: données -void UmatAbaqus::Affiche(ofstream& sort,const int niveau) +void UmatAbaqus::Affiche(ostream& sort,const int niveau) { sort << "\n *********** info umat ************ "; sort << "\n sigma_t "; for (int i=0;i<6;i++) sort << "("<& nom) +void Hexa::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element Hexa (hexaedre trilineaire "<nbi<<" pt d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/Hexa.h b/Elements/Mecanique/Hexaedre/Hexa.h index 1492d72..965bc8b 100644 --- a/Elements/Mecanique/Hexaedre/Hexa.h +++ b/Elements/Mecanique/Hexaedre/Hexa.h @@ -122,7 +122,7 @@ class Hexa : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/HexaLMemb.cc b/Elements/Mecanique/Hexaedre/HexaLMemb.cc index c847ed3..21a1d52 100644 --- a/Elements/Mecanique/Hexaedre/HexaLMemb.cc +++ b/Elements/Mecanique/Hexaedre/HexaLMemb.cc @@ -215,7 +215,7 @@ Hexa::~Hexa () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void Hexa::AfficheVarDual(ofstream& sort, Tableau& nom) +void Hexa::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element Hexa (hexaedre trilineaire "<nbi<<" pt d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaLMemb.h b/Elements/Mecanique/Hexaedre/HexaLMemb.h index 6737a97..f3359f1 100644 --- a/Elements/Mecanique/Hexaedre/HexaLMemb.h +++ b/Elements/Mecanique/Hexaedre/HexaLMemb.h @@ -119,7 +119,7 @@ class HexaLMemb : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/HexaMemb.cc b/Elements/Mecanique/Hexaedre/HexaMemb.cc index 00cacc8..e56b094 100644 --- a/Elements/Mecanique/Hexaedre/HexaMemb.cc +++ b/Elements/Mecanique/Hexaedre/HexaMemb.cc @@ -406,7 +406,7 @@ Mat_pleine * HexaMemb::CalculMatriceMasse (Enum_calcul_masse type_calcul_masse) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void HexaMemb::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de l'élément @@ -425,7 +425,7 @@ void HexaMemb::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "HexaMemb::Lecture_base_info(ifstream& ent,const " + cout << "HexaMemb::Lecture_base_info(istream& ent,const " << "Tableau * tabMaillageNoeud,const int cas)" << " cas= " << cas << endl; Sortie(1); @@ -436,7 +436,7 @@ void HexaMemb::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void HexaMemb::Ecriture_base_info(ofstream& sort,const int cas) +void HexaMemb::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de l'élément @@ -454,7 +454,7 @@ void HexaMemb::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "HexaMemb::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "HexaMemb::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Mecanique/Hexaedre/HexaMemb.h b/Elements/Mecanique/Hexaedre/HexaMemb.h index 3e4f376..0de6336 100644 --- a/Elements/Mecanique/Hexaedre/HexaMemb.h +++ b/Elements/Mecanique/Hexaedre/HexaMemb.h @@ -282,11 +282,11 @@ class HexaMemb : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // 2) derivant des virtuelles diff --git a/Elements/Mecanique/Hexaedre/HexaQ.cc b/Elements/Mecanique/Hexaedre/HexaQ.cc index 8e933f2..f52c0da 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ.cc +++ b/Elements/Mecanique/Hexaedre/HexaQ.cc @@ -288,7 +288,7 @@ list HexaQ::Construct_from_lineaire(const Element & elem,list & nom) +void HexaQ::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element HexaQ (hexaedre triquadratique "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaQ.h b/Elements/Mecanique/Hexaedre/HexaQ.h index 6158e18..51c268f 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ.h +++ b/Elements/Mecanique/Hexaedre/HexaQ.h @@ -123,7 +123,7 @@ class HexaQ : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // renseignement d'un élément quadratique incomplet à partir d'un élément linéaire de même type diff --git a/Elements/Mecanique/Hexaedre/HexaQComp.cc b/Elements/Mecanique/Hexaedre/HexaQComp.cc index 63bfd7a..8163551 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp.cc +++ b/Elements/Mecanique/Hexaedre/HexaQComp.cc @@ -304,7 +304,7 @@ list HexaQComp::Construct_from_imcomplet(const Element & elem,list & nom) +void HexaQComp::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element HexaQComp (hexaedre triquadratique complet "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp.h b/Elements/Mecanique/Hexaedre/HexaQComp.h index 9220a5b..5518e5b 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp.h +++ b/Elements/Mecanique/Hexaedre/HexaQComp.h @@ -131,7 +131,7 @@ class HexaQComp : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc b/Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc index 3ccea73..b329d80 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc @@ -219,7 +219,7 @@ HexaQComp_cm1pti::~HexaQComp_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void HexaQComp_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void HexaQComp_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element HexaQComp_cm1pti (hexaedre triquadratique complet "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc b/Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc index df93961..c85d4c4 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc @@ -213,7 +213,7 @@ HexaQComp_cm27pti::~HexaQComp_cm27pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void HexaQComp_cm27pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void HexaQComp_cm27pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element HexaQComp_cm27pti (hexaedre triquadratique complet "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc b/Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc index a9722e9..dee92da 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc @@ -210,7 +210,7 @@ HexaQComp_cm64pti::~HexaQComp_cm64pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void HexaQComp_cm64pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void HexaQComp_cm64pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element HexaQComp_cm64pti (hexaedre triquadratique complet "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h b/Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h index 498422b..03103b6 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h @@ -122,7 +122,7 @@ class HexaQComp_cm1pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h b/Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h index 977e466..6666f9e 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h @@ -122,7 +122,7 @@ class HexaQComp_cm27pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h b/Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h index 017ca12..3ae7fe5 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h @@ -122,7 +122,7 @@ class HexaQComp_cm64pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc b/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc index 6183529..1b0521b 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc @@ -222,7 +222,7 @@ HexaQ_cm1pti::~HexaQ_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void HexaQ_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void HexaQ_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element HexaQ_cm1pti (hexaedre triquadratique "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h b/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h index e46deab..52b2e5e 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h @@ -122,7 +122,7 @@ class HexaQ_cm1pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc b/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc index e864e36..959805f 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc @@ -216,7 +216,7 @@ HexaQ_cm27pti::~HexaQ_cm27pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void HexaQ_cm27pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void HexaQ_cm27pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element HexaQ_cm27pti (hexaedre triquadratique "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h b/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h index 49e8127..5d727bc 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h @@ -122,7 +122,7 @@ class HexaQ_cm27pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc b/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc index cc0b6a8..d5f5584 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc @@ -216,7 +216,7 @@ HexaQ_cm64pti::~HexaQ_cm64pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void HexaQ_cm64pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void HexaQ_cm64pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element HexaQ_cm64pti (hexaedre triquadratique "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h b/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h index ee41b59..e58a840 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h @@ -122,7 +122,7 @@ class HexaQ_cm64pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc b/Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc index fb092db..6bc6d7a 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc +++ b/Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc @@ -215,7 +215,7 @@ Hexa_cm1pti::~Hexa_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void Hexa_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void Hexa_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element Hexa_cm1pti (hexaedre trilineaire "<nbi<<" pt d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm1pti.h b/Elements/Mecanique/Hexaedre/Hexa_cm1pti.h index cbd603b..2cb9634 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm1pti.h +++ b/Elements/Mecanique/Hexaedre/Hexa_cm1pti.h @@ -117,7 +117,7 @@ class Hexa_cm1pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc b/Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc index b326325..8a6f088 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc +++ b/Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc @@ -207,7 +207,7 @@ Hexa_cm27pti::~Hexa_cm27pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void Hexa_cm27pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void Hexa_cm27pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element Hexa_cm27pti (hexaedre trilineaire "<nbi<<" pt d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm27pti.h b/Elements/Mecanique/Hexaedre/Hexa_cm27pti.h index 1566079..5c99caa 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm27pti.h +++ b/Elements/Mecanique/Hexaedre/Hexa_cm27pti.h @@ -117,7 +117,7 @@ class Hexa_cm27pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc b/Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc index 14ba070..7907d1d 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc +++ b/Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc @@ -208,7 +208,7 @@ Hexa_cm64pti::~Hexa_cm64pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void Hexa_cm64pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void Hexa_cm64pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element Hexa_cm64pti (hexaedre trilineaire "<nbi<<" pt d'integration) "; diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm64pti.h b/Elements/Mecanique/Hexaedre/Hexa_cm64pti.h index 3da1b38..74b0706 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm64pti.h +++ b/Elements/Mecanique/Hexaedre/Hexa_cm64pti.h @@ -117,7 +117,7 @@ class Hexa_cm64pti : public HexaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/LesChargeExtSurElement.cc b/Elements/Mecanique/LesChargeExtSurElement.cc index cd96b7a..b4ea6dd 100755 --- a/Elements/Mecanique/LesChargeExtSurElement.cc +++ b/Elements/Mecanique/LesChargeExtSurElement.cc @@ -315,14 +315,14 @@ void LesChargeExtSurElement::LesLineiqueSuiveuse_Change_taille(int n) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesChargeExtSurElement::Lecture_base_info (ifstream& ent,const int ) +void LesChargeExtSurElement::Lecture_base_info (istream& ent,const int ) { // l'entrée est identique quelque soit la valeur de cas ent >> (*this); }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesChargeExtSurElement::Ecriture_base_info(ofstream& sort,const int ) +void LesChargeExtSurElement::Ecriture_base_info(ostream& sort,const int ) { // la sortie est identique quelque soit la valeur de cas sort << (*this); }; diff --git a/Elements/Mecanique/LesChargeExtSurElement.h b/Elements/Mecanique/LesChargeExtSurElement.h index ce86dd9..c9f3176 100755 --- a/Elements/Mecanique/LesChargeExtSurElement.h +++ b/Elements/Mecanique/LesChargeExtSurElement.h @@ -174,11 +174,11 @@ class LesChargeExtSurElement // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected: // données protégées diff --git a/Elements/Mecanique/LesPtIntegMecaInterne.cc b/Elements/Mecanique/LesPtIntegMecaInterne.cc index 099f568..bde12cd 100644 --- a/Elements/Mecanique/LesPtIntegMecaInterne.cc +++ b/Elements/Mecanique/LesPtIntegMecaInterne.cc @@ -119,7 +119,7 @@ int LesPtIntegMecaInterne::DimTens() const // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesPtIntegMecaInterne::Lecture_base_info (ifstream& ent,const int cas) +void LesPtIntegMecaInterne::Lecture_base_info (istream& ent,const int cas) {switch (cas) { case 1 : // ------- on récupère tout ------------------------- { string nom; ent >> nom; // on ne vérifie pas le nom car on considère que @@ -153,7 +153,7 @@ void LesPtIntegMecaInterne::Lecture_base_info (ifstream& ent,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "LesPtIntegMecaInterne::Lecture_base_info(ifstream& ent,const " + cout << "LesPtIntegMecaInterne::Lecture_base_info(istream& ent,const " << " cas= " << cas << endl; Sortie(1); }; @@ -162,7 +162,7 @@ void LesPtIntegMecaInterne::Lecture_base_info (ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesPtIntegMecaInterne::Ecriture_base_info(ofstream& sort,const int cas) +void LesPtIntegMecaInterne::Ecriture_base_info(ostream& sort,const int cas) {switch (cas) { case 1 : // ------- on sauvegarde tout ------------------------- { sort << "\n grandeurs_aux_points_d_integration:" ; @@ -185,7 +185,7 @@ void LesPtIntegMecaInterne::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "LesPtIntegMecaInterne::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "LesPtIntegMecaInterne::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); }; diff --git a/Elements/Mecanique/LesPtIntegMecaInterne.h b/Elements/Mecanique/LesPtIntegMecaInterne.h index bed59ca..516dbb9 100644 --- a/Elements/Mecanique/LesPtIntegMecaInterne.h +++ b/Elements/Mecanique/LesPtIntegMecaInterne.h @@ -122,11 +122,11 @@ class LesPtIntegMecaInterne // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected: // données protégées diff --git a/Elements/Mecanique/Pentaedre/PentaL.cc b/Elements/Mecanique/Pentaedre/PentaL.cc index e925eeb..fadadf3 100644 --- a/Elements/Mecanique/Pentaedre/PentaL.cc +++ b/Elements/Mecanique/Pentaedre/PentaL.cc @@ -226,7 +226,7 @@ PentaL::~PentaL () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaL::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaL::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; diff --git a/Elements/Mecanique/Pentaedre/PentaL.h b/Elements/Mecanique/Pentaedre/PentaL.h index 0fb0b19..32ecc10 100644 --- a/Elements/Mecanique/Pentaedre/PentaL.h +++ b/Elements/Mecanique/Pentaedre/PentaL.h @@ -124,7 +124,7 @@ class PentaL : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Pentaedre/PentaL_cm1pti.cc b/Elements/Mecanique/Pentaedre/PentaL_cm1pti.cc index dedb92c..f08eed5 100644 --- a/Elements/Mecanique/Pentaedre/PentaL_cm1pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaL_cm1pti.cc @@ -225,7 +225,7 @@ PentaL_cm1pti::~PentaL_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaL_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaL_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; diff --git a/Elements/Mecanique/Pentaedre/PentaL_cm1pti.h b/Elements/Mecanique/Pentaedre/PentaL_cm1pti.h index b2d431f..620a9ec 100644 --- a/Elements/Mecanique/Pentaedre/PentaL_cm1pti.h +++ b/Elements/Mecanique/Pentaedre/PentaL_cm1pti.h @@ -124,7 +124,7 @@ class PentaL_cm1pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Pentaedre/PentaL_cm2pti.cc b/Elements/Mecanique/Pentaedre/PentaL_cm2pti.cc index d97902e..d9e4d28 100644 --- a/Elements/Mecanique/Pentaedre/PentaL_cm2pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaL_cm2pti.cc @@ -225,7 +225,7 @@ PentaL_cm2pti::~PentaL_cm2pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaL_cm2pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaL_cm2pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; diff --git a/Elements/Mecanique/Pentaedre/PentaL_cm2pti.h b/Elements/Mecanique/Pentaedre/PentaL_cm2pti.h index a8d6234..f26f05c 100644 --- a/Elements/Mecanique/Pentaedre/PentaL_cm2pti.h +++ b/Elements/Mecanique/Pentaedre/PentaL_cm2pti.h @@ -124,7 +124,7 @@ class PentaL_cm2pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Pentaedre/PentaL_cm6pti.cc b/Elements/Mecanique/Pentaedre/PentaL_cm6pti.cc index 2a37877..902fff2 100644 --- a/Elements/Mecanique/Pentaedre/PentaL_cm6pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaL_cm6pti.cc @@ -219,7 +219,7 @@ PentaL_cm6pti::~PentaL_cm6pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaL_cm6pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaL_cm6pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; diff --git a/Elements/Mecanique/Pentaedre/PentaL_cm6pti.h b/Elements/Mecanique/Pentaedre/PentaL_cm6pti.h index 28b82db..bf226a8 100644 --- a/Elements/Mecanique/Pentaedre/PentaL_cm6pti.h +++ b/Elements/Mecanique/Pentaedre/PentaL_cm6pti.h @@ -124,7 +124,7 @@ class PentaL_cm6pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Pentaedre/PentaMemb.cc b/Elements/Mecanique/Pentaedre/PentaMemb.cc index ed63a7a..72a343f 100644 --- a/Elements/Mecanique/Pentaedre/PentaMemb.cc +++ b/Elements/Mecanique/Pentaedre/PentaMemb.cc @@ -401,7 +401,7 @@ Mat_pleine * PentaMemb::CalculMatriceMasse (Enum_calcul_masse type_calcul_masse) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void PentaMemb::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de l'élément @@ -420,7 +420,7 @@ void PentaMemb::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "PentaMemb::Lecture_base_info(ifstream& ent,const " + cout << "PentaMemb::Lecture_base_info(istream& ent,const " << "Tableau * tabMaillageNoeud,const int cas)" << " cas= " << cas << endl; Sortie(1); @@ -431,7 +431,7 @@ void PentaMemb::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void PentaMemb::Ecriture_base_info(ofstream& sort,const int cas) +void PentaMemb::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de l'élément @@ -449,7 +449,7 @@ void PentaMemb::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "PentaMemb::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "PentaMemb::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Mecanique/Pentaedre/PentaMemb.h b/Elements/Mecanique/Pentaedre/PentaMemb.h index 3cf9f9b..62f009d 100644 --- a/Elements/Mecanique/Pentaedre/PentaMemb.h +++ b/Elements/Mecanique/Pentaedre/PentaMemb.h @@ -284,11 +284,11 @@ class PentaMemb : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // 2) derivant des virtuelles diff --git a/Elements/Mecanique/Pentaedre/PentaQ.cc b/Elements/Mecanique/Pentaedre/PentaQ.cc index 39ea473..7832f29 100644 --- a/Elements/Mecanique/Pentaedre/PentaQ.cc +++ b/Elements/Mecanique/Pentaedre/PentaQ.cc @@ -225,7 +225,7 @@ PentaQ::~PentaQ () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaQ::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaQ::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQ (pentaedre trilquadratique incomplet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQ.h b/Elements/Mecanique/Pentaedre/PentaQ.h index 5c94257..5d4e2bf 100644 --- a/Elements/Mecanique/Pentaedre/PentaQ.h +++ b/Elements/Mecanique/Pentaedre/PentaQ.h @@ -124,7 +124,7 @@ class PentaQ : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Pentaedre/PentaQComp.cc b/Elements/Mecanique/Pentaedre/PentaQComp.cc index da90f01..a850187 100644 --- a/Elements/Mecanique/Pentaedre/PentaQComp.cc +++ b/Elements/Mecanique/Pentaedre/PentaQComp.cc @@ -326,7 +326,7 @@ list PentaQComp::Construct_from_imcomplet(const Element & elem,list & nom) +void PentaQComp::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQComp (pentaedre trilquadratique complet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQComp.h b/Elements/Mecanique/Pentaedre/PentaQComp.h index fa68084..ad74d2f 100644 --- a/Elements/Mecanique/Pentaedre/PentaQComp.h +++ b/Elements/Mecanique/Pentaedre/PentaQComp.h @@ -133,7 +133,7 @@ class PentaQComp : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Pentaedre/PentaQComp_cm12pti.cc b/Elements/Mecanique/Pentaedre/PentaQComp_cm12pti.cc index 93f325a..0712c06 100644 --- a/Elements/Mecanique/Pentaedre/PentaQComp_cm12pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaQComp_cm12pti.cc @@ -219,7 +219,7 @@ PentaQComp_cm12pti::~PentaQComp_cm12pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaQComp_cm12pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaQComp_cm12pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQComp_cm12pti (pentaedre trilquadratique complet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQComp_cm12pti.h b/Elements/Mecanique/Pentaedre/PentaQComp_cm12pti.h index b41b774..9a8b7ef 100644 --- a/Elements/Mecanique/Pentaedre/PentaQComp_cm12pti.h +++ b/Elements/Mecanique/Pentaedre/PentaQComp_cm12pti.h @@ -125,7 +125,7 @@ class PentaQComp_cm12pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Pentaedre/PentaQComp_cm18pti.cc b/Elements/Mecanique/Pentaedre/PentaQComp_cm18pti.cc index d47d278..5310af0 100644 --- a/Elements/Mecanique/Pentaedre/PentaQComp_cm18pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaQComp_cm18pti.cc @@ -219,7 +219,7 @@ PentaQComp_cm18pti::~PentaQComp_cm18pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaQComp_cm18pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaQComp_cm18pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQComp_cm18pti (pentaedre trilquadratique complet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQComp_cm18pti.h b/Elements/Mecanique/Pentaedre/PentaQComp_cm18pti.h index 3e76583..43d4c44 100644 --- a/Elements/Mecanique/Pentaedre/PentaQComp_cm18pti.h +++ b/Elements/Mecanique/Pentaedre/PentaQComp_cm18pti.h @@ -125,7 +125,7 @@ class PentaQComp_cm18pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Pentaedre/PentaQComp_cm9pti.cc b/Elements/Mecanique/Pentaedre/PentaQComp_cm9pti.cc index 2cc9717..0b7ca25 100644 --- a/Elements/Mecanique/Pentaedre/PentaQComp_cm9pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaQComp_cm9pti.cc @@ -219,7 +219,7 @@ PentaQComp_cm9pti::~PentaQComp_cm9pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaQComp_cm9pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaQComp_cm9pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQComp_cm9pti (pentaedre trilquadratique complet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQComp_cm9pti.h b/Elements/Mecanique/Pentaedre/PentaQComp_cm9pti.h index 42312af..6be091f 100644 --- a/Elements/Mecanique/Pentaedre/PentaQComp_cm9pti.h +++ b/Elements/Mecanique/Pentaedre/PentaQComp_cm9pti.h @@ -125,7 +125,7 @@ class PentaQComp_cm9pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Pentaedre/PentaQ_cm12pti.cc b/Elements/Mecanique/Pentaedre/PentaQ_cm12pti.cc index 29b0194..b84b1ff 100644 --- a/Elements/Mecanique/Pentaedre/PentaQ_cm12pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaQ_cm12pti.cc @@ -219,7 +219,7 @@ PentaQ_cm12pti::~PentaQ_cm12pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaQ_cm12pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaQ_cm12pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQ_cm12pti (pentaedre trilquadratique incomplet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQ_cm12pti.h b/Elements/Mecanique/Pentaedre/PentaQ_cm12pti.h index 889f970..29f5323 100644 --- a/Elements/Mecanique/Pentaedre/PentaQ_cm12pti.h +++ b/Elements/Mecanique/Pentaedre/PentaQ_cm12pti.h @@ -125,7 +125,7 @@ class PentaQ_cm12pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Pentaedre/PentaQ_cm18pti.cc b/Elements/Mecanique/Pentaedre/PentaQ_cm18pti.cc index f68297f..35c1387 100644 --- a/Elements/Mecanique/Pentaedre/PentaQ_cm18pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaQ_cm18pti.cc @@ -219,7 +219,7 @@ PentaQ_cm18pti::~PentaQ_cm18pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaQ_cm18pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaQ_cm18pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQ_cm18pti (pentaedre trilquadratique incomplet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQ_cm18pti.h b/Elements/Mecanique/Pentaedre/PentaQ_cm18pti.h index 93f1c92..51d4097 100644 --- a/Elements/Mecanique/Pentaedre/PentaQ_cm18pti.h +++ b/Elements/Mecanique/Pentaedre/PentaQ_cm18pti.h @@ -125,7 +125,7 @@ class PentaQ_cm18pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Pentaedre/PentaQ_cm3pti.cc b/Elements/Mecanique/Pentaedre/PentaQ_cm3pti.cc index 8066360..c1b0351 100755 --- a/Elements/Mecanique/Pentaedre/PentaQ_cm3pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaQ_cm3pti.cc @@ -225,7 +225,7 @@ PentaQ_cm3pti::~PentaQ_cm3pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaQ_cm3pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaQ_cm3pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQ_cm3pti (pentaedre trilquadratique incomplet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQ_cm3pti.h b/Elements/Mecanique/Pentaedre/PentaQ_cm3pti.h index c3e4c23..271fb36 100755 --- a/Elements/Mecanique/Pentaedre/PentaQ_cm3pti.h +++ b/Elements/Mecanique/Pentaedre/PentaQ_cm3pti.h @@ -125,7 +125,7 @@ class PentaQ_cm3pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Pentaedre/PentaQ_cm9pti.cc b/Elements/Mecanique/Pentaedre/PentaQ_cm9pti.cc index e2fe216..97a00c5 100644 --- a/Elements/Mecanique/Pentaedre/PentaQ_cm9pti.cc +++ b/Elements/Mecanique/Pentaedre/PentaQ_cm9pti.cc @@ -219,7 +219,7 @@ PentaQ_cm9pti::~PentaQ_cm9pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void PentaQ_cm9pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void PentaQ_cm9pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************"; sort << "\n Element PentaQ_cm9pti (pentaedre trilquadratique incomplet " << nombre->nbI << " pt d'integration) "; diff --git a/Elements/Mecanique/Pentaedre/PentaQ_cm9pti.h b/Elements/Mecanique/Pentaedre/PentaQ_cm9pti.h index ac5318c..c924c4d 100644 --- a/Elements/Mecanique/Pentaedre/PentaQ_cm9pti.h +++ b/Elements/Mecanique/Pentaedre/PentaQ_cm9pti.h @@ -125,7 +125,7 @@ class PentaQ_cm9pti : public PentaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/PtIntegMecaInterne.cc b/Elements/Mecanique/PtIntegMecaInterne.cc index ab0a439..de10766 100644 --- a/Elements/Mecanique/PtIntegMecaInterne.cc +++ b/Elements/Mecanique/PtIntegMecaInterne.cc @@ -232,7 +232,7 @@ PtIntegMecaInterne& PtIntegMecaInterne::operator= ( const PtIntegMecaInterne& pt // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void PtIntegMecaInterne::Lecture_base_info (ifstream& ent,const int ) +void PtIntegMecaInterne::Lecture_base_info (istream& ent,const int ) { // lecture des différents éléments que l'on trouve utiles (pour l'instant) string nom; ent >> nom; epsBB->Lecture(ent); @@ -285,7 +285,7 @@ void PtIntegMecaInterne::Lecture_base_info (ifstream& ent,const int ) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void PtIntegMecaInterne::Ecriture_base_info(ofstream& sort,const int ) +void PtIntegMecaInterne::Ecriture_base_info(ostream& sort,const int ) { // les différents éléments que l'on considère intéressant (pour l'instant) sort << "\n epsBB= "; epsBB->Ecriture(sort); sort << "\n depsBB= "; depsBB->Ecriture(sort); diff --git a/Elements/Mecanique/PtIntegMecaInterne.h b/Elements/Mecanique/PtIntegMecaInterne.h index 175c1b8..eedc41d 100644 --- a/Elements/Mecanique/PtIntegMecaInterne.h +++ b/Elements/Mecanique/PtIntegMecaInterne.h @@ -251,11 +251,11 @@ class PtIntegMecaInterne // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected : diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom.cc b/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom.cc index 58d242c..02d5ad7 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom.cc +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom.cc @@ -152,7 +152,7 @@ QuadAxiCCom::~QuadAxiCCom () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadAxiCCom::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadAxiCCom::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n***********************************************************************"; sort << "\n Element QuadAxiCCom (quad axi cubique complet 16 pt d'integration) "; diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom.h b/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom.h index b7df082..aec14a8 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom.h +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom.h @@ -120,7 +120,7 @@ class QuadAxiCCom : public QuadAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom_cm9pti.cc b/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom_cm9pti.cc index 14360f1..ad0393f 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom_cm9pti.cc +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom_cm9pti.cc @@ -153,7 +153,7 @@ QuadAxiCCom_cm9pti::~QuadAxiCCom_cm9pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadAxiCCom_cm9pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadAxiCCom_cm9pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n****************************************************************************"; sort << "\n Element QuadAxiCCom_cm9pti (quad axi cubique complet 9 pt d'integration) "; diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom_cm9pti.h b/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom_cm9pti.h index f860548..a523c70 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom_cm9pti.h +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiCCom_cm9pti.h @@ -120,7 +120,7 @@ class QuadAxiCCom_cm9pti : public QuadAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1.cc b/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1.cc index 0964896..81f4c32 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1.cc +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1.cc @@ -179,7 +179,7 @@ QuadAxiL1::~QuadAxiL1 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void QuadAxiL1::AfficheVarDual(ofstream& sort, Tableau& nom) + void QuadAxiL1::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n***************************************************************************"; sort << "\n Element QuadAxiL1 (quadrangle axisymetrique lineaire 4 pt d'integration) "; diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1.h b/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1.h index 8197130..89ef870 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1.h +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1.h @@ -119,7 +119,7 @@ class QuadAxiL1 : public QuadAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1_cm1pti.cc b/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1_cm1pti.cc index 78c0220..4bbc23b 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1_cm1pti.cc +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1_cm1pti.cc @@ -180,7 +180,7 @@ QuadAxiL1_cm1pti::~QuadAxiL1_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void QuadAxiL1_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) + void QuadAxiL1_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n*********************************************************************************"; sort << "\n Element QuadAxiL1_cm1pti (quadrangle axisymetrique lineaire 1 pt d'integration) "; diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1_cm1pti.h b/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1_cm1pti.h index 1055289..1244722 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1_cm1pti.h +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiL1_cm1pti.h @@ -120,7 +120,7 @@ class QuadAxiL1_cm1pti : public QuadAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiMemb.cc b/Elements/Mecanique/Quad_asisymetrie/QuadAxiMemb.cc index c085425..cf90863 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiMemb.cc +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiMemb.cc @@ -386,7 +386,7 @@ Mat_pleine * QuadAxiMemb::CalculMatriceMasse (Enum_calcul_masse type_calcul_mass // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void QuadAxiMemb::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier du quadrangle @@ -405,7 +405,7 @@ void QuadAxiMemb::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "QuadAxiMemb::Lecture_base_info(ifstream& ent,const " + cout << "QuadAxiMemb::Lecture_base_info(istream& ent,const " << "Tableau * tabMaillageNoeud,const int cas)" << " cas= " << cas << endl; Sortie(1); @@ -416,7 +416,7 @@ void QuadAxiMemb::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void QuadAxiMemb::Ecriture_base_info(ofstream& sort,const int cas) +void QuadAxiMemb::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier du quadrangle @@ -434,7 +434,7 @@ void QuadAxiMemb::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "QuadAxiMemb::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "QuadAxiMemb::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiMemb.h b/Elements/Mecanique/Quad_asisymetrie/QuadAxiMemb.h index 08fe127..dfd4f68 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiMemb.h +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiMemb.h @@ -266,11 +266,11 @@ class QuadAxiMemb : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // 2) derivant des virtuelles diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQ.cc b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQ.cc index 91747fa..28083de 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQ.cc +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQ.cc @@ -178,7 +178,7 @@ QuadAxiQ::~QuadAxiQ () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadAxiQ::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadAxiQ::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n*****************************************************************************"; sort << "\n Element QuadAxiQ (quadrangle axisymetrique quadratique 4 pt d'integration) "; diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQ.h b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQ.h index 188d2ba..7fa3074 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQ.h +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQ.h @@ -118,7 +118,7 @@ class QuadAxiQ : public QuadAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp.cc b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp.cc index b8be74f..d005aff 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp.cc +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp.cc @@ -179,7 +179,7 @@ QuadAxiQComp::~QuadAxiQComp () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadAxiQComp::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadAxiQComp::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n****************************************************************************************"; sort << "\n Element QuadAxiQComp (quadrangle axisymetrique quadratique complet 4 pt d'integration) "; diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp.h b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp.h index c5fe6cd..406c83e 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp.h +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp.h @@ -119,7 +119,7 @@ class QuadAxiQComp : public QuadAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp_cm4pti.cc b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp_cm4pti.cc index 7fdede9..edff1a8 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp_cm4pti.cc +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp_cm4pti.cc @@ -179,7 +179,7 @@ QuadAxiQComp_cm4pti::~QuadAxiQComp_cm4pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadAxiQComp_cm4pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadAxiQComp_cm4pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n***********************************************************************************************"; sort << "\n Element QuadAxiQComp_cm4pti (quadrangle axisymetrique quadratique complet 4 pt d'integration) "; diff --git a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp_cm4pti.h b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp_cm4pti.h index c0e2c50..4d7b6f2 100644 --- a/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp_cm4pti.h +++ b/Elements/Mecanique/Quad_asisymetrie/QuadAxiQComp_cm4pti.h @@ -120,7 +120,7 @@ class QuadAxiQComp_cm4pti : public QuadAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/SFE/DeformationSfe1.h b/Elements/Mecanique/SFE/DeformationSfe1.h index 562d61a..931d5f8 100644 --- a/Elements/Mecanique/SFE/DeformationSfe1.h +++ b/Elements/Mecanique/SFE/DeformationSfe1.h @@ -120,17 +120,17 @@ class DeformationSfe1 : public Deformation // affichage des infos virtual void Affiche(); - // idem sur un ofstream - virtual void Affiche(ofstream& sort); + // idem sur un ostream + virtual void Affiche(ostream& sort); //============= lecture écriture dans base info ========== // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info (ifstream& ent,const int cas); + virtual void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas); + virtual void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif, ou l'inverse virtual void TdtversT() {meti_a_t = meti_a_tdt;}; @@ -158,7 +158,7 @@ class DeformationSfe1 : public Deformation virtual SaveDefResul * New_et_Initialise() {return (new SaveDefResulSfe1(*metrique));}; // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) - virtual void AfficheDataSpecif(ofstream& sort,SaveDefResul * a) const {a->Affiche(sort);}; + virtual void AfficheDataSpecif(ostream& sort,SaveDefResul * a) const {a->Affiche(sort);}; // met à jour les données spécifiques du point considéré void Mise_a_jour_data_specif(Deformation::SaveDefResul* don) {saveDefResul=don;}; diff --git a/Elements/Mecanique/SFE/SfeMembT.cc b/Elements/Mecanique/SFE/SfeMembT.cc index ca05cac..61c6738 100644 --- a/Elements/Mecanique/SFE/SfeMembT.cc +++ b/Elements/Mecanique/SFE/SfeMembT.cc @@ -1100,7 +1100,7 @@ Mat_pleine * SfeMembT::CalculMatriceMasse (Enum_calcul_masse type_calcul_masse) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void SfeMembT::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de l'élément centrale @@ -1167,7 +1167,7 @@ void SfeMembT::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "SfeMembT::::Lecture_base_info(ifstream& ent,const " + cout << "SfeMembT::::Lecture_base_info(istream& ent,const " << "Tableau * tabMaillageNoeud,const int cas)" << " cas= " << cas << endl; Sortie(1); @@ -1178,7 +1178,7 @@ void SfeMembT::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void SfeMembT::Ecriture_base_info(ofstream& sort,const int cas) +void SfeMembT::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de l'élément central @@ -1224,7 +1224,7 @@ void SfeMembT::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "SfeMembT::::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "SfeMembT::::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Mecanique/SFE/SfeMembT.h b/Elements/Mecanique/SFE/SfeMembT.h index 94dca26..a864617 100644 --- a/Elements/Mecanique/SFE/SfeMembT.h +++ b/Elements/Mecanique/SFE/SfeMembT.h @@ -341,11 +341,11 @@ class SfeMembT : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // 2) derivant des virtuelles diff --git a/Elements/Mecanique/SFE/TriaQSfe1.cc b/Elements/Mecanique/SFE/TriaQSfe1.cc index f929dc6..c2d2b40 100755 --- a/Elements/Mecanique/SFE/TriaQSfe1.cc +++ b/Elements/Mecanique/SFE/TriaQSfe1.cc @@ -246,7 +246,7 @@ TriaQSfe1::~TriaQSfe1 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaQSfe1::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaQSfe1::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaQSfe1 (triangle QSFE1 2 pt d'integration dans l'epaisseur et 3 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaQSfe1.h b/Elements/Mecanique/SFE/TriaQSfe1.h index ccded57..cd6385b 100755 --- a/Elements/Mecanique/SFE/TriaQSfe1.h +++ b/Elements/Mecanique/SFE/TriaQSfe1.h @@ -138,7 +138,7 @@ class TriaQSfe1 : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaQSfe3.cc b/Elements/Mecanique/SFE/TriaQSfe3.cc index 8fc1e47..04de500 100755 --- a/Elements/Mecanique/SFE/TriaQSfe3.cc +++ b/Elements/Mecanique/SFE/TriaQSfe3.cc @@ -245,7 +245,7 @@ TriaQSfe3::~TriaQSfe3 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaQSfe3::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaQSfe3::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaQSfe3 (triangle QSFE3 2 pt d'integration dans l'epaisseur et 3 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaQSfe3.h b/Elements/Mecanique/SFE/TriaQSfe3.h index d129101..c792f54 100755 --- a/Elements/Mecanique/SFE/TriaQSfe3.h +++ b/Elements/Mecanique/SFE/TriaQSfe3.h @@ -139,7 +139,7 @@ class TriaQSfe3 : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe1.cc b/Elements/Mecanique/SFE/TriaSfe1.cc index 8b312f1..2eb9556 100644 --- a/Elements/Mecanique/SFE/TriaSfe1.cc +++ b/Elements/Mecanique/SFE/TriaSfe1.cc @@ -246,7 +246,7 @@ TriaSfe1::~TriaSfe1 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe1::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe1::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaSfe1 (triangle SFE1 2 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe1.h b/Elements/Mecanique/SFE/TriaSfe1.h index 27213b7..8003fd9 100644 --- a/Elements/Mecanique/SFE/TriaSfe1.h +++ b/Elements/Mecanique/SFE/TriaSfe1.h @@ -140,7 +140,7 @@ class TriaSfe1 : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe1_cm5pti.cc b/Elements/Mecanique/SFE/TriaSfe1_cm5pti.cc index a6e5526..3993ffb 100755 --- a/Elements/Mecanique/SFE/TriaSfe1_cm5pti.cc +++ b/Elements/Mecanique/SFE/TriaSfe1_cm5pti.cc @@ -249,7 +249,7 @@ TriaSfe1_cm5pti::~TriaSfe1_cm5pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe1_cm5pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe1_cm5pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaSfe1_cm5pti (triangle SFE1 5 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe1_cm5pti.h b/Elements/Mecanique/SFE/TriaSfe1_cm5pti.h index 40639ba..b5d27d0 100755 --- a/Elements/Mecanique/SFE/TriaSfe1_cm5pti.h +++ b/Elements/Mecanique/SFE/TriaSfe1_cm5pti.h @@ -139,7 +139,7 @@ class TriaSfe1_cm5pti : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe2.cc b/Elements/Mecanique/SFE/TriaSfe2.cc index d09d594..0a2a994 100644 --- a/Elements/Mecanique/SFE/TriaSfe2.cc +++ b/Elements/Mecanique/SFE/TriaSfe2.cc @@ -246,7 +246,7 @@ TriaSfe2::~TriaSfe2 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe2::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe2::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaSfe2 (triangle SFE2 2 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe2.h b/Elements/Mecanique/SFE/TriaSfe2.h index a10ac52..443f975 100644 --- a/Elements/Mecanique/SFE/TriaSfe2.h +++ b/Elements/Mecanique/SFE/TriaSfe2.h @@ -137,7 +137,7 @@ class TriaSfe2 : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3.cc b/Elements/Mecanique/SFE/TriaSfe3.cc index c37e676..74f13a6 100644 --- a/Elements/Mecanique/SFE/TriaSfe3.cc +++ b/Elements/Mecanique/SFE/TriaSfe3.cc @@ -245,7 +245,7 @@ TriaSfe3::~TriaSfe3 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaSfe3 (triangle SFE3 2 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3.h b/Elements/Mecanique/SFE/TriaSfe3.h index da37b7d..27d8461 100644 --- a/Elements/Mecanique/SFE/TriaSfe3.h +++ b/Elements/Mecanique/SFE/TriaSfe3.h @@ -132,7 +132,7 @@ class TriaSfe3 : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3C.cc b/Elements/Mecanique/SFE/TriaSfe3C.cc index c3c1d2d..7615d47 100644 --- a/Elements/Mecanique/SFE/TriaSfe3C.cc +++ b/Elements/Mecanique/SFE/TriaSfe3C.cc @@ -250,7 +250,7 @@ TriaSfe3C::~TriaSfe3C () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3C::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3C::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaSfe3C (triangle Sfe3C 2 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3C.h b/Elements/Mecanique/SFE/TriaSfe3C.h index 440b430..b987241 100644 --- a/Elements/Mecanique/SFE/TriaSfe3C.h +++ b/Elements/Mecanique/SFE/TriaSfe3C.h @@ -133,7 +133,7 @@ class TriaSfe3C : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3_3D.cc b/Elements/Mecanique/SFE/TriaSfe3_3D.cc index 3e9702f..89d3555 100644 --- a/Elements/Mecanique/SFE/TriaSfe3_3D.cc +++ b/Elements/Mecanique/SFE/TriaSfe3_3D.cc @@ -232,7 +232,7 @@ TriaSfe3_3D::~TriaSfe3_3D () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3_3D::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3_3D::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n********************************************************************************************"; sort << "\n Element TriaSfe3_3D (triangle SFE3_3D "<nbie<<" pt d'integration dans l'epaisseur et " diff --git a/Elements/Mecanique/SFE/TriaSfe3_3D.h b/Elements/Mecanique/SFE/TriaSfe3_3D.h index b52f9bf..d602e07 100644 --- a/Elements/Mecanique/SFE/TriaSfe3_3D.h +++ b/Elements/Mecanique/SFE/TriaSfe3_3D.h @@ -131,7 +131,7 @@ class TriaSfe3_3D : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm12pti.cc b/Elements/Mecanique/SFE/TriaSfe3_cm12pti.cc index 51af5ab..b2737ab 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm12pti.cc +++ b/Elements/Mecanique/SFE/TriaSfe3_cm12pti.cc @@ -252,7 +252,7 @@ TriaSfe3_cm12pti::~TriaSfe3_cm12pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3_cm12pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3_cm12pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaSfe3_cm12pti (triangle SFE3 12 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm12pti.h b/Elements/Mecanique/SFE/TriaSfe3_cm12pti.h index 80f5d99..3861bdf 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm12pti.h +++ b/Elements/Mecanique/SFE/TriaSfe3_cm12pti.h @@ -133,7 +133,7 @@ class TriaSfe3_cm12pti : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm13pti.cc b/Elements/Mecanique/SFE/TriaSfe3_cm13pti.cc index 05fb4bb..2863a89 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm13pti.cc +++ b/Elements/Mecanique/SFE/TriaSfe3_cm13pti.cc @@ -255,7 +255,7 @@ TriaSfe3_cm13pti::~TriaSfe3_cm13pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3_cm13pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3_cm13pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n*********************************************************************************************"; sort << "\n Element TriaSfe3_cm13pti (triangle SFE3 13 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm13pti.h b/Elements/Mecanique/SFE/TriaSfe3_cm13pti.h index f613029..f9152ec 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm13pti.h +++ b/Elements/Mecanique/SFE/TriaSfe3_cm13pti.h @@ -133,7 +133,7 @@ class TriaSfe3_cm13pti : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm3pti.cc b/Elements/Mecanique/SFE/TriaSfe3_cm3pti.cc index afd4124..52ff39f 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm3pti.cc +++ b/Elements/Mecanique/SFE/TriaSfe3_cm3pti.cc @@ -255,7 +255,7 @@ TriaSfe3_cm3pti::~TriaSfe3_cm3pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3_cm3pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3_cm3pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n*********************************************************************************************"; sort << "\n Element TriaSfe3_cm3pti (triangle SFE3 3 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm3pti.h b/Elements/Mecanique/SFE/TriaSfe3_cm3pti.h index 0df90a6..7af7af2 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm3pti.h +++ b/Elements/Mecanique/SFE/TriaSfe3_cm3pti.h @@ -134,7 +134,7 @@ class TriaSfe3_cm3pti : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm4pti.cc b/Elements/Mecanique/SFE/TriaSfe3_cm4pti.cc index 982051a..4058f9d 100644 --- a/Elements/Mecanique/SFE/TriaSfe3_cm4pti.cc +++ b/Elements/Mecanique/SFE/TriaSfe3_cm4pti.cc @@ -255,7 +255,7 @@ TriaSfe3_cm4pti::~TriaSfe3_cm4pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3_cm4pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3_cm4pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaSfe3_cm4pti (triangle SFE3 4 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm4pti.h b/Elements/Mecanique/SFE/TriaSfe3_cm4pti.h index 59e4326..00061af 100644 --- a/Elements/Mecanique/SFE/TriaSfe3_cm4pti.h +++ b/Elements/Mecanique/SFE/TriaSfe3_cm4pti.h @@ -134,7 +134,7 @@ class TriaSfe3_cm4pti : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm5pti.cc b/Elements/Mecanique/SFE/TriaSfe3_cm5pti.cc index 20f435c..275c579 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm5pti.cc +++ b/Elements/Mecanique/SFE/TriaSfe3_cm5pti.cc @@ -255,7 +255,7 @@ TriaSfe3_cm5pti::~TriaSfe3_cm5pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3_cm5pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3_cm5pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n*********************************************************************************************"; sort << "\n Element TriaSfe3_cm5pti (triangle SFE3 5 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm5pti.h b/Elements/Mecanique/SFE/TriaSfe3_cm5pti.h index 2da275c..73cdf45 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm5pti.h +++ b/Elements/Mecanique/SFE/TriaSfe3_cm5pti.h @@ -136,7 +136,7 @@ class TriaSfe3_cm5pti : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm6pti.cc b/Elements/Mecanique/SFE/TriaSfe3_cm6pti.cc index a562678..4f68933 100644 --- a/Elements/Mecanique/SFE/TriaSfe3_cm6pti.cc +++ b/Elements/Mecanique/SFE/TriaSfe3_cm6pti.cc @@ -252,7 +252,7 @@ TriaSfe3_cm6pti::~TriaSfe3_cm6pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3_cm6pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3_cm6pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**************************************************************************************"; sort << "\n Element TriaSfe3_cm6pti (triangle SFE3 2 pt d'integration dans l'epaisseur et 3 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm6pti.h b/Elements/Mecanique/SFE/TriaSfe3_cm6pti.h index 1db9cf4..d7915d9 100644 --- a/Elements/Mecanique/SFE/TriaSfe3_cm6pti.h +++ b/Elements/Mecanique/SFE/TriaSfe3_cm6pti.h @@ -133,7 +133,7 @@ class TriaSfe3_cm6pti : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm7pti.cc b/Elements/Mecanique/SFE/TriaSfe3_cm7pti.cc index 4fa3394..e817dc0 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm7pti.cc +++ b/Elements/Mecanique/SFE/TriaSfe3_cm7pti.cc @@ -255,7 +255,7 @@ TriaSfe3_cm7pti::~TriaSfe3_cm7pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaSfe3_cm7pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaSfe3_cm7pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n*********************************************************************************************"; sort << "\n Element TriaSfe3_cm7pti (triangle SFE3 7 pt d'integration dans l'epaisseur et 1 de surface) "; diff --git a/Elements/Mecanique/SFE/TriaSfe3_cm7pti.h b/Elements/Mecanique/SFE/TriaSfe3_cm7pti.h index c69d45b..f1ed2b9 100755 --- a/Elements/Mecanique/SFE/TriaSfe3_cm7pti.h +++ b/Elements/Mecanique/SFE/TriaSfe3_cm7pti.h @@ -132,7 +132,7 @@ class TriaSfe3_cm7pti : public SfeMembT // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Tetraedre/Tetra.cc b/Elements/Mecanique/Tetraedre/Tetra.cc index 8727fdc..6896df5 100644 --- a/Elements/Mecanique/Tetraedre/Tetra.cc +++ b/Elements/Mecanique/Tetraedre/Tetra.cc @@ -220,7 +220,7 @@ Tetra::~Tetra () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void Tetra::AfficheVarDual(ofstream& sort, Tableau& nom) +void Tetra::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element Tetra (tetraedre trilineaire "<nbi<<" pt d'integration) "; diff --git a/Elements/Mecanique/Tetraedre/Tetra.h b/Elements/Mecanique/Tetraedre/Tetra.h index 742706d..9b63ab3 100644 --- a/Elements/Mecanique/Tetraedre/Tetra.h +++ b/Elements/Mecanique/Tetraedre/Tetra.h @@ -123,7 +123,7 @@ class Tetra : public TetraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Tetraedre/TetraMemb.cc b/Elements/Mecanique/Tetraedre/TetraMemb.cc index 103baee..b65b2f3 100644 --- a/Elements/Mecanique/Tetraedre/TetraMemb.cc +++ b/Elements/Mecanique/Tetraedre/TetraMemb.cc @@ -405,7 +405,7 @@ Mat_pleine * TetraMemb::CalculMatriceMasse (Enum_calcul_masse type_calcul_masse) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void TetraMemb::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de l'élément @@ -424,7 +424,7 @@ void TetraMemb::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "TetraMemb::Lecture_base_info(ifstream& ent,const " + cout << "TetraMemb::Lecture_base_info(istream& ent,const " << "Tableau * tabMaillageNoeud,const int cas)" << " cas= " << cas << endl; Sortie(1); @@ -435,7 +435,7 @@ void TetraMemb::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void TetraMemb::Ecriture_base_info(ofstream& sort,const int cas) +void TetraMemb::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de l'élément @@ -453,7 +453,7 @@ void TetraMemb::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "TetraMemb::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "TetraMemb::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Mecanique/Tetraedre/TetraMemb.h b/Elements/Mecanique/Tetraedre/TetraMemb.h index 380d249..02d73a9 100644 --- a/Elements/Mecanique/Tetraedre/TetraMemb.h +++ b/Elements/Mecanique/Tetraedre/TetraMemb.h @@ -283,11 +283,11 @@ class TetraMemb : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // 2) derivant des virtuelles diff --git a/Elements/Mecanique/Tetraedre/TetraQ.cc b/Elements/Mecanique/Tetraedre/TetraQ.cc index 7f299a9..99f5f3d 100644 --- a/Elements/Mecanique/Tetraedre/TetraQ.cc +++ b/Elements/Mecanique/Tetraedre/TetraQ.cc @@ -221,7 +221,7 @@ TetraQ::~TetraQ () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TetraQ::AfficheVarDual(ofstream& sort, Tableau& nom) +void TetraQ::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element TetraQ (tetraedre triquadratique "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Tetraedre/TetraQ.h b/Elements/Mecanique/Tetraedre/TetraQ.h index 302744e..f8ba6b6 100644 --- a/Elements/Mecanique/Tetraedre/TetraQ.h +++ b/Elements/Mecanique/Tetraedre/TetraQ.h @@ -122,7 +122,7 @@ class TetraQ : public TetraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Tetraedre/TetraQ_cm15pti.cc b/Elements/Mecanique/Tetraedre/TetraQ_cm15pti.cc index 4ec931e..913d8e8 100755 --- a/Elements/Mecanique/Tetraedre/TetraQ_cm15pti.cc +++ b/Elements/Mecanique/Tetraedre/TetraQ_cm15pti.cc @@ -221,7 +221,7 @@ TetraQ_15pti::~TetraQ_15pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TetraQ_15pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TetraQ_15pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element TetraQ_15pti (tetraedre triquadratique "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Tetraedre/TetraQ_cm15pti.h b/Elements/Mecanique/Tetraedre/TetraQ_cm15pti.h index 61311ab..6267121 100755 --- a/Elements/Mecanique/Tetraedre/TetraQ_cm15pti.h +++ b/Elements/Mecanique/Tetraedre/TetraQ_cm15pti.h @@ -122,7 +122,7 @@ class TetraQ_15pti : public TetraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Tetraedre/TetraQ_cm1pti.cc b/Elements/Mecanique/Tetraedre/TetraQ_cm1pti.cc index 04e3198..1fb6dbc 100755 --- a/Elements/Mecanique/Tetraedre/TetraQ_cm1pti.cc +++ b/Elements/Mecanique/Tetraedre/TetraQ_cm1pti.cc @@ -227,7 +227,7 @@ TetraQ_cm1pti::~TetraQ_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TetraQ_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TetraQ_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element TetraQ_cm1pti (tetraedre triquadratique "<nbi<<" pts d'integration) "; diff --git a/Elements/Mecanique/Tetraedre/TetraQ_cm1pti.h b/Elements/Mecanique/Tetraedre/TetraQ_cm1pti.h index d758d08..3569f49 100755 --- a/Elements/Mecanique/Tetraedre/TetraQ_cm1pti.h +++ b/Elements/Mecanique/Tetraedre/TetraQ_cm1pti.h @@ -122,7 +122,7 @@ class TetraQ_cm1pti : public TetraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiL1.cc b/Elements/Mecanique/Tria_axisymetrie/TriaAxiL1.cc index 2108bf5..e94edde 100644 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiL1.cc +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiL1.cc @@ -179,7 +179,7 @@ TriaAxiL1::~TriaAxiL1 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void TriaAxiL1::AfficheVarDual(ofstream& sort, Tableau& nom) + void TriaAxiL1::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n************************************************************************"; sort << "\n Element TriaAxiL1 (triangle axisymetrique lineaire 1 pt d'integration) "; diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiL1.h b/Elements/Mecanique/Tria_axisymetrie/TriaAxiL1.h index 18a5066..910a4fc 100644 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiL1.h +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiL1.h @@ -121,7 +121,7 @@ class TriaAxiL1 : public TriaAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiMemb.cc b/Elements/Mecanique/Tria_axisymetrie/TriaAxiMemb.cc index 9f41a18..0197721 100644 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiMemb.cc +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiMemb.cc @@ -386,7 +386,7 @@ Mat_pleine * TriaAxiMemb::CalculMatriceMasse (Enum_calcul_masse type_calcul_mass // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void TriaAxiMemb::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier du triangle @@ -405,7 +405,7 @@ void TriaAxiMemb::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "TriaAxiMemb::Lecture_base_info(ifstream& ent,const " + cout << "TriaAxiMemb::Lecture_base_info(istream& ent,const " << "Tableau * tabMaillageNoeud,const int cas)" << " cas= " << cas << endl; Sortie(1); @@ -416,7 +416,7 @@ void TriaAxiMemb::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void TriaAxiMemb::Ecriture_base_info(ofstream& sort,const int cas) +void TriaAxiMemb::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier du triangle @@ -434,7 +434,7 @@ void TriaAxiMemb::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "TriaAxiMemb::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "TriaAxiMemb::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiMemb.h b/Elements/Mecanique/Tria_axisymetrie/TriaAxiMemb.h index 5b28bcb..8a200ea 100644 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiMemb.h +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiMemb.h @@ -267,11 +267,11 @@ class TriaAxiMemb : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // 2) derivant des virtuelles diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3.cc b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3.cc index 4224884..f3f3af2 100644 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3.cc +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3.cc @@ -178,7 +178,7 @@ TriaAxiQ3::~TriaAxiQ3 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaAxiQ3::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaAxiQ3::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n***************************************************************************"; sort << "\n Element TriaAxiQ3 (triangle axisymetrique quadratique 3 pt d'integration) "; diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3.h b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3.h index c5c6b5a..454020e 100644 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3.h +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3.h @@ -126,7 +126,7 @@ class TriaAxiQ3 : public TriaAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cm1pti.cc b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cm1pti.cc index 4380992..ed477d7 100644 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cm1pti.cc +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cm1pti.cc @@ -179,7 +179,7 @@ TriaAxiQ3_cm1pti::~TriaAxiQ3_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaAxiQ3_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaAxiQ3_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**********************************************************************************"; sort << "\n Element TriaAxiQ3_cm1pti (triangle axisymetrique quadratique 1 pt d'integration) "; diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cm1pti.h b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cm1pti.h index 4a1abfb..aa4088b 100644 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cm1pti.h +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cm1pti.h @@ -125,7 +125,7 @@ class TriaAxiQ3_cm1pti : public TriaAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cmpti1003.cc b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cmpti1003.cc index d7acccf..009974b 100755 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cmpti1003.cc +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cmpti1003.cc @@ -184,7 +184,7 @@ TriaAxiQ3_cmpti1003::~TriaAxiQ3_cmpti1003 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaAxiQ3_cmpti1003::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaAxiQ3_cmpti1003::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n**********************************************************************************"; sort << "\n Element TriaAxiQ3_cmpti1003 (triangle axisymetrique quadratique 3 pti hors arretes) "; diff --git a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cmpti1003.h b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cmpti1003.h index c2cd442..cdfd735 100755 --- a/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cmpti1003.h +++ b/Elements/Mecanique/Tria_axisymetrie/TriaAxiQ3_cmpti1003.h @@ -119,7 +119,7 @@ class TriaAxiQ3_cmpti1003 : public TriaAxiMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Triangle/TriaCub.cc b/Elements/Mecanique/Triangle/TriaCub.cc index 72ff916..3600b0d 100644 --- a/Elements/Mecanique/Triangle/TriaCub.cc +++ b/Elements/Mecanique/Triangle/TriaCub.cc @@ -204,7 +204,7 @@ TriaCub::~TriaCub () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaCub::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaCub::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element TriaCub (triangle cubique 3 pt d'integration) "; diff --git a/Elements/Mecanique/Triangle/TriaCub.h b/Elements/Mecanique/Triangle/TriaCub.h index bc92f92..5084a54 100644 --- a/Elements/Mecanique/Triangle/TriaCub.h +++ b/Elements/Mecanique/Triangle/TriaCub.h @@ -120,7 +120,7 @@ class TriaCub : public TriaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Triangle/TriaCub_cm4pti.cc b/Elements/Mecanique/Triangle/TriaCub_cm4pti.cc index b6b8d2e..7aa4fba 100644 --- a/Elements/Mecanique/Triangle/TriaCub_cm4pti.cc +++ b/Elements/Mecanique/Triangle/TriaCub_cm4pti.cc @@ -205,7 +205,7 @@ TriaCub_cm4pti::~TriaCub_cm4pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaCub_cm4pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaCub_cm4pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element TriaCub_cm4pti (triangle cubique 4 pt d'integration) "; diff --git a/Elements/Mecanique/Triangle/TriaCub_cm4pti.h b/Elements/Mecanique/Triangle/TriaCub_cm4pti.h index 64ca526..79ddba6 100644 --- a/Elements/Mecanique/Triangle/TriaCub_cm4pti.h +++ b/Elements/Mecanique/Triangle/TriaCub_cm4pti.h @@ -123,7 +123,7 @@ class TriaCub_cm4pti : public TriaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Triangle/TriaMemb.cc b/Elements/Mecanique/Triangle/TriaMemb.cc index 3d206f2..f6fbc6e 100644 --- a/Elements/Mecanique/Triangle/TriaMemb.cc +++ b/Elements/Mecanique/Triangle/TriaMemb.cc @@ -493,7 +493,7 @@ Mat_pleine * TriaMemb::CalculMatriceMasse (Enum_calcul_masse type_calcul_masse) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void TriaMemb::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier du triangle @@ -530,7 +530,7 @@ void TriaMemb::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "TriaMemb::Lecture_base_info(ifstream& ent,const " + cout << "TriaMemb::Lecture_base_info(istream& ent,const " << "Tableau * tabMaillageNoeud,const int cas)" << " cas= " << cas << endl; Sortie(1); @@ -541,7 +541,7 @@ void TriaMemb::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void TriaMemb::Ecriture_base_info(ofstream& sort,const int cas) +void TriaMemb::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier du triangle @@ -568,7 +568,7 @@ void TriaMemb::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "TriaMemb::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "TriaMemb::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Mecanique/Triangle/TriaMemb.h b/Elements/Mecanique/Triangle/TriaMemb.h index 2897097..d06d710 100644 --- a/Elements/Mecanique/Triangle/TriaMemb.h +++ b/Elements/Mecanique/Triangle/TriaMemb.h @@ -339,11 +339,11 @@ class TriaMemb : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // 2) derivant des virtuelles diff --git a/Elements/Mecanique/Triangle/TriaMembL1.cc b/Elements/Mecanique/Triangle/TriaMembL1.cc index b96b542..93c0488 100644 --- a/Elements/Mecanique/Triangle/TriaMembL1.cc +++ b/Elements/Mecanique/Triangle/TriaMembL1.cc @@ -205,7 +205,7 @@ TriaMembL1::~TriaMembL1 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void TriaMembL1::AfficheVarDual(ofstream& sort, Tableau& nom) + void TriaMembL1::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element TriaMembL1 (triangle lineaire 1 pt d'integration) "; diff --git a/Elements/Mecanique/Triangle/TriaMembL1.h b/Elements/Mecanique/Triangle/TriaMembL1.h index 262f6c6..2a39b8c 100644 --- a/Elements/Mecanique/Triangle/TriaMembL1.h +++ b/Elements/Mecanique/Triangle/TriaMembL1.h @@ -134,7 +134,7 @@ class TriaMembL1 : public TriaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/Triangle/TriaMembQ3.cc b/Elements/Mecanique/Triangle/TriaMembQ3.cc index 158e7cf..7ae60d6 100644 --- a/Elements/Mecanique/Triangle/TriaMembQ3.cc +++ b/Elements/Mecanique/Triangle/TriaMembQ3.cc @@ -204,7 +204,7 @@ TriaMembQ3::~TriaMembQ3 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaMembQ3::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaMembQ3::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element TriaMembQ3 (triangle quadratique 3 pt d'integration) "; diff --git a/Elements/Mecanique/Triangle/TriaMembQ3.h b/Elements/Mecanique/Triangle/TriaMembQ3.h index c2c3c37..6883476 100644 --- a/Elements/Mecanique/Triangle/TriaMembQ3.h +++ b/Elements/Mecanique/Triangle/TriaMembQ3.h @@ -128,7 +128,7 @@ class TriaMembQ3 : public TriaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Triangle/TriaMembQ3_cm1pti.cc b/Elements/Mecanique/Triangle/TriaMembQ3_cm1pti.cc index e6141fa..05ae9ca 100644 --- a/Elements/Mecanique/Triangle/TriaMembQ3_cm1pti.cc +++ b/Elements/Mecanique/Triangle/TriaMembQ3_cm1pti.cc @@ -205,7 +205,7 @@ TriaMembQ3_cm1pti::~TriaMembQ3_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaMembQ3_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaMembQ3_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element TriaMembQ3_cm1pti (triangle quadratique 1 pt d'integration) "; diff --git a/Elements/Mecanique/Triangle/TriaMembQ3_cm1pti.h b/Elements/Mecanique/Triangle/TriaMembQ3_cm1pti.h index f7ec86a..021a9b1 100644 --- a/Elements/Mecanique/Triangle/TriaMembQ3_cm1pti.h +++ b/Elements/Mecanique/Triangle/TriaMembQ3_cm1pti.h @@ -120,7 +120,7 @@ class TriaMembQ3_cm1pti : public TriaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/Triangle/TriaQ3_cmpti1003.cc b/Elements/Mecanique/Triangle/TriaQ3_cmpti1003.cc index d47dca5..33ca32f 100644 --- a/Elements/Mecanique/Triangle/TriaQ3_cmpti1003.cc +++ b/Elements/Mecanique/Triangle/TriaQ3_cmpti1003.cc @@ -210,7 +210,7 @@ TriaQ3_cmpti1003::~TriaQ3_cmpti1003 () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void TriaQ3_cmpti1003::AfficheVarDual(ofstream& sort, Tableau& nom) +void TriaQ3_cmpti1003::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n*********************************************************************************"; sort << "\n Element TriaQ3_cmpti1003 (triangle quadratique 3 pt d'integration hors arretes) "; diff --git a/Elements/Mecanique/Triangle/TriaQ3_cmpti1003.h b/Elements/Mecanique/Triangle/TriaQ3_cmpti1003.h index cd8e77f..bf3f9e7 100644 --- a/Elements/Mecanique/Triangle/TriaQ3_cmpti1003.h +++ b/Elements/Mecanique/Triangle/TriaQ3_cmpti1003.h @@ -130,7 +130,7 @@ class TriaQ3_cmpti1003 : public TriaMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); protected : diff --git a/Elements/Mecanique/quadrangle/Quad.cc b/Elements/Mecanique/quadrangle/Quad.cc index 4b0003d..7a3c3f9 100644 --- a/Elements/Mecanique/quadrangle/Quad.cc +++ b/Elements/Mecanique/quadrangle/Quad.cc @@ -210,7 +210,7 @@ Quad::~Quad () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void Quad::AfficheVarDual(ofstream& sort, Tableau& nom) +void Quad::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element Quad (quadrangle lineaire 4 pt d'integration) "; diff --git a/Elements/Mecanique/quadrangle/Quad.h b/Elements/Mecanique/quadrangle/Quad.h index 27914e5..32ad6cf 100644 --- a/Elements/Mecanique/quadrangle/Quad.h +++ b/Elements/Mecanique/quadrangle/Quad.h @@ -124,7 +124,7 @@ class Quad : public QuadraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles diff --git a/Elements/Mecanique/quadrangle/QuadCCom.cc b/Elements/Mecanique/quadrangle/QuadCCom.cc index 0856811..7d9c6d5 100644 --- a/Elements/Mecanique/quadrangle/QuadCCom.cc +++ b/Elements/Mecanique/quadrangle/QuadCCom.cc @@ -215,7 +215,7 @@ QuadCCom::~QuadCCom () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadCCom::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadCCom::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n***********************************************************************"; sort << "\n Element QuadCCom (quadrangle cubique complet 9 pt d'integration) "; diff --git a/Elements/Mecanique/quadrangle/QuadCCom.h b/Elements/Mecanique/quadrangle/QuadCCom.h index 7eb9809..b389d27 100644 --- a/Elements/Mecanique/quadrangle/QuadCCom.h +++ b/Elements/Mecanique/quadrangle/QuadCCom.h @@ -124,7 +124,7 @@ class QuadCCom : public QuadraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/quadrangle/QuadCCom_cm9pti.cc b/Elements/Mecanique/quadrangle/QuadCCom_cm9pti.cc index 000b354..f17441a 100644 --- a/Elements/Mecanique/quadrangle/QuadCCom_cm9pti.cc +++ b/Elements/Mecanique/quadrangle/QuadCCom_cm9pti.cc @@ -216,7 +216,7 @@ QuadCCom_cm9pti::~QuadCCom_cm9pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadCCom_cm9pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadCCom_cm9pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n***********************************************************************"; sort << "\n Element QuadCCom_cm9pti (quadrangle cubique complet 9 pt d'integration) "; diff --git a/Elements/Mecanique/quadrangle/QuadCCom_cm9pti.h b/Elements/Mecanique/quadrangle/QuadCCom_cm9pti.h index 4bceeb5..a021b85 100644 --- a/Elements/Mecanique/quadrangle/QuadCCom_cm9pti.h +++ b/Elements/Mecanique/quadrangle/QuadCCom_cm9pti.h @@ -124,7 +124,7 @@ class QuadCCom_cm9pti : public QuadraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/quadrangle/QuadQ.cc b/Elements/Mecanique/quadrangle/QuadQ.cc index de60c1a..726514d 100644 --- a/Elements/Mecanique/quadrangle/QuadQ.cc +++ b/Elements/Mecanique/quadrangle/QuadQ.cc @@ -208,7 +208,7 @@ QuadQ::~QuadQ () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadQ::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadQ::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element QuadQ (quadrangle quadratique 4 pt d'integration) "; diff --git a/Elements/Mecanique/quadrangle/QuadQ.h b/Elements/Mecanique/quadrangle/QuadQ.h index caf7a95..a22140d 100644 --- a/Elements/Mecanique/quadrangle/QuadQ.h +++ b/Elements/Mecanique/quadrangle/QuadQ.h @@ -124,7 +124,7 @@ class QuadQ : public QuadraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/quadrangle/QuadQCom.cc b/Elements/Mecanique/quadrangle/QuadQCom.cc index 47ea443..ae7c2eb 100644 --- a/Elements/Mecanique/quadrangle/QuadQCom.cc +++ b/Elements/Mecanique/quadrangle/QuadQCom.cc @@ -286,7 +286,7 @@ list QuadQCom::Construct_from_imcomplet(const Element & elem,list & nom) +void QuadQCom::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n***********************************************************************"; sort << "\n Element QuadQCom (quadrangle quadratique complet 9 pt d'integration) "; diff --git a/Elements/Mecanique/quadrangle/QuadQCom.h b/Elements/Mecanique/quadrangle/QuadQCom.h index 094be36..50b66cf 100644 --- a/Elements/Mecanique/quadrangle/QuadQCom.h +++ b/Elements/Mecanique/quadrangle/QuadQCom.h @@ -134,7 +134,7 @@ class QuadQCom : public QuadraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/quadrangle/QuadQCom_cm4pti.cc b/Elements/Mecanique/quadrangle/QuadQCom_cm4pti.cc index f719ed0..47c4bb0 100644 --- a/Elements/Mecanique/quadrangle/QuadQCom_cm4pti.cc +++ b/Elements/Mecanique/quadrangle/QuadQCom_cm4pti.cc @@ -287,7 +287,7 @@ list QuadQCom_cm4pti::Construct_from_imcomplet(const Element & elem,li // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void QuadQCom_cm4pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void QuadQCom_cm4pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n***********************************************************************"; sort << "\n Element QuadQCom_cm4pti (quadrangle quadratique complet 4 pt d'integration) "; diff --git a/Elements/Mecanique/quadrangle/QuadQCom_cm4pti.h b/Elements/Mecanique/quadrangle/QuadQCom_cm4pti.h index 5000716..6de3c32 100644 --- a/Elements/Mecanique/quadrangle/QuadQCom_cm4pti.h +++ b/Elements/Mecanique/quadrangle/QuadQCom_cm4pti.h @@ -133,7 +133,7 @@ class QuadQCom_cm4pti : public QuadraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles // 3) methodes propres a l'element diff --git a/Elements/Mecanique/quadrangle/Quad_cm1pti.cc b/Elements/Mecanique/quadrangle/Quad_cm1pti.cc index 4c06b30..746bfe7 100644 --- a/Elements/Mecanique/quadrangle/Quad_cm1pti.cc +++ b/Elements/Mecanique/quadrangle/Quad_cm1pti.cc @@ -211,7 +211,7 @@ Quad_cm1pti::~Quad_cm1pti () // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void Quad_cm1pti::AfficheVarDual(ofstream& sort, Tableau& nom) +void Quad_cm1pti::AfficheVarDual(ostream& sort, Tableau& nom) { // affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element Quad_cm1pti (quadrangle lineaire 1 pt d'integration) "; diff --git a/Elements/Mecanique/quadrangle/Quad_cm1pti.h b/Elements/Mecanique/quadrangle/Quad_cm1pti.h index 019512f..1cfd920 100644 --- a/Elements/Mecanique/quadrangle/Quad_cm1pti.h +++ b/Elements/Mecanique/quadrangle/Quad_cm1pti.h @@ -124,7 +124,7 @@ class Quad_cm1pti : public QuadraMemb // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // 2) derivant des virtuelles diff --git a/Elements/Mecanique/quadrangle/QuadraMemb.cc b/Elements/Mecanique/quadrangle/QuadraMemb.cc index 61c49e1..79f9641 100644 --- a/Elements/Mecanique/quadrangle/QuadraMemb.cc +++ b/Elements/Mecanique/quadrangle/QuadraMemb.cc @@ -522,7 +522,7 @@ Mat_pleine * QuadraMemb::CalculMatriceMasse (Enum_calcul_masse type_calcul_masse // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void QuadraMemb::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe elem_meca ElemMeca::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier du quadrangle @@ -560,7 +560,7 @@ void QuadraMemb::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "QuadraMemb::Lecture_base_info(ifstream& ent,const " + cout << "QuadraMemb::Lecture_base_info(istream& ent,const " << "Tableau * tabMaillageNoeud,const int cas)" << " cas= " << cas << endl; Sortie(1); @@ -571,7 +571,7 @@ void QuadraMemb::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void QuadraMemb::Ecriture_base_info(ofstream& sort,const int cas) +void QuadraMemb::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe elem_meca ElemMeca::Ecriture_bas_inf(sort,cas); // traitement du cas particulier du quadrangle @@ -598,7 +598,7 @@ void QuadraMemb::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "QuadraMemb::::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "QuadraMemb::::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); }; diff --git a/Elements/Mecanique/quadrangle/QuadraMemb.h b/Elements/Mecanique/quadrangle/QuadraMemb.h index 47d488c..d162a18 100644 --- a/Elements/Mecanique/quadrangle/QuadraMemb.h +++ b/Elements/Mecanique/quadrangle/QuadraMemb.h @@ -342,11 +342,11 @@ class QuadraMemb : public ElemMeca // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // 2) derivant des virtuelles diff --git a/Elements/ResRaid_MPI.cc b/Elements/ResRaid_MPI.cc index 96bbcf2..4dc396c 100755 --- a/Elements/ResRaid_MPI.cc +++ b/Elements/ResRaid_MPI.cc @@ -92,14 +92,14 @@ void ResRaid_MPI::Affectation(const DeuxEntiers& elem, const Vecteur* ress, cons // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void ResRaid_MPI::Lecture_base_info(ifstream& ent,const int cas) +void ResRaid_MPI::Lecture_base_info(istream& ent,const int cas) { // on suit exactement la même procédure que pour archive // load(ent,cas); }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void ResRaid_MPI::Ecriture_base_info(ofstream& sort,const int cas) +void ResRaid_MPI::Ecriture_base_info(ostream& sort,const int cas) { // on suit exactement la même procédure que pour archive // save(sort,cas); }; diff --git a/Elements/ResRaid_MPI.h b/Elements/ResRaid_MPI.h index c6b8be8..27e0b25 100755 --- a/Elements/ResRaid_MPI.h +++ b/Elements/ResRaid_MPI.h @@ -95,11 +95,11 @@ class ResRaid_MPI // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // récupération des infos int Num_elt() const {return val_de_base(1);}; // numero d'identification de l'element diff --git a/Elements/Thermique/Biellette/BielletteThermi.cc b/Elements/Thermique/Biellette/BielletteThermi.cc index 7730c0f..9ea0452 100755 --- a/Elements/Thermique/Biellette/BielletteThermi.cc +++ b/Elements/Thermique/Biellette/BielletteThermi.cc @@ -578,7 +578,7 @@ const DeuxCoordonnees& BielletteThermi::Boite_encombre_element(Enum_dure temps) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void BielletteThermi::Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) {// tout d'abord appel de la lecture de la classe ElemThermi ElemThermi::Lecture_bas_inf(ent,tabMaillageNoeud,cas); // traitement du cas particulier de la biellette @@ -610,7 +610,7 @@ void BielletteThermi::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "BielletteThermi::Lecture_base_info(ofstream& sort,int cas)" + cout << "BielletteThermi::Lecture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -620,7 +620,7 @@ void BielletteThermi::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void BielletteThermi::Ecriture_base_info(ofstream& sort,const int cas) +void BielletteThermi::Ecriture_base_info(ostream& sort,const int cas) {// tout d'abord appel de l'écriture de la classe ElemThermi ElemThermi::Ecriture_bas_inf(sort,cas); // traitement du cas particulier de la biellette @@ -644,7 +644,7 @@ void BielletteThermi::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "BielletteThermi::Ecriture_base_info(ofstream& sort,int cas)" + cout << "BielletteThermi::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -818,7 +818,7 @@ int BielletteThermi::TestComplet() // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void BielletteThermi::AfficheVarDual(ofstream& sort, Tableau& nom) + void BielletteThermi::AfficheVarDual(ostream& sort, Tableau& nom) {// affichage de l'entête de l'element sort << "\n******************************************************************"; sort << "\n Element bielette (2 noeuds 1 point d'integration) "; diff --git a/Elements/Thermique/Biellette/BielletteThermi.h b/Elements/Thermique/Biellette/BielletteThermi.h index bdb10d5..6a46c95 100755 --- a/Elements/Thermique/Biellette/BielletteThermi.h +++ b/Elements/Thermique/Biellette/BielletteThermi.h @@ -197,7 +197,7 @@ class BielletteThermi : public ElemThermi // affichage dans la sortie transmise, des variables duales "nom" // dans le cas ou nom est vide, affichage de "toute" les variables - void AfficheVarDual(ofstream& sort, Tableau& nom); + void AfficheVarDual(ostream& sort, Tableau& nom); // affichage d'info en fonction de ordre // ordre = "commande" : affichage d'un exemple d'entree pour l'élément @@ -243,11 +243,11 @@ class BielletteThermi : public ElemThermi // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_base_info - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) ; + void Ecriture_base_info(ostream& sort,const int cas) ; // METHODES VIRTUELLES: // --------- calculs utils dans le cadre de la recherche du flambement linéaire diff --git a/Elements/Thermique/ElemThermi.h b/Elements/Thermique/ElemThermi.h index deebc0d..343d092 100755 --- a/Elements/Thermique/ElemThermi.h +++ b/Elements/Thermique/ElemThermi.h @@ -692,30 +692,30 @@ class ElemThermi : public Element // cas = 2 -> premier passage pour de l'explicit // cas = 11 -> passage autre que le premier pour de l'implicit // cas = 12 -> passage autre que le premier pour de l'explicit - void VarDualSort(ofstream& sort, Tableau& nom,int nbint,int cas); + void VarDualSort(ostream& sort, Tableau& nom,int nbint,int cas); // utilitaires de VarDualSort // affiche en fonction d'indic les differentes variables et appel // AffDefContiD en fonction de la dimension i // - void AffDefCont( ofstream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, + void AffDefCont( ostream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, CoordonneeB& gradTB,Coordonnee& gradT,double& norme_gradT, CoordonneeB& DgradTB,Coordonnee& DgradT,double& norme_dGradT, CoordonneeH& fluxDH,Coordonnee & fluxD,double& norme_flux, double& temperature, int indic); // cas 1D - void AffDefCont1D( ofstream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, + void AffDefCont1D( ostream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, CoordonneeB& gradTB,Coordonnee& gradT,double& norme_gradT, CoordonneeB& DgradTB,Coordonnee& DgradT,double& norme_dGradT, CoordonneeH& fluxDH,Coordonnee & fluxD,double& norme_flux, double& temperature, int indic); // cas 2D - void AffDefCont2D( ofstream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, + void AffDefCont2D( ostream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, CoordonneeB& gradTB,Coordonnee& gradT,double& norme_gradT, CoordonneeB& DgradTB,Coordonnee& DgradT,double& norme_dGradT, CoordonneeH& fluxDH,Coordonnee & fluxD,double& norme_flux, double& temperature, int indic); // cas 3D - void AffDefCont3D( ofstream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, + void AffDefCont3D( ostream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, CoordonneeB& gradTB,Coordonnee& gradT,double& norme_gradT, CoordonneeB& DgradTB,Coordonnee& DgradT,double& norme_dGradT, CoordonneeH& fluxDH,Coordonnee & fluxD,double& norme_flux, @@ -756,11 +756,11 @@ class ElemThermi : public Element // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lecture_bas_inf - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) ; + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_bas_inf(ofstream& sort,const int cas) ; + void Ecriture_bas_inf(ostream& sort,const int cas) ; // --------- utilitaires pour la dynamique // calcul de la longueur d'arrête de l'élément minimal diff --git a/Elements/Thermique/ElemThermi2.cc b/Elements/Thermique/ElemThermi2.cc index 68d2c44..94dcc27 100755 --- a/Elements/Thermique/ElemThermi2.cc +++ b/Elements/Thermique/ElemThermi2.cc @@ -385,7 +385,7 @@ void ElemThermi::FluxEnAbsolues // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void ElemThermi::Lecture_bas_inf - (ifstream& ent,const Tableau * tabMaillageNoeud,const int cas) + (istream& ent,const Tableau * tabMaillageNoeud,const int cas) { // appel de la routine d'élément Element::Lect_bas_inf_element(ent,tabMaillageNoeud,cas);switch (cas) { case 1 : // ------- on récupère tout ------------------------- @@ -404,7 +404,7 @@ void ElemThermi::Lecture_bas_inf } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "ElemThermi::Lecture_bas_inf (ifstream& ent,const int cas)" + cout << "ElemThermi::Lecture_bas_inf (istream& ent,const int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -450,7 +450,7 @@ void ElemThermi::Lecture_bas_inf // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void ElemThermi::Ecriture_bas_inf(ofstream& sort,const int cas) +void ElemThermi::Ecriture_bas_inf(ostream& sort,const int cas) { // appel de la routine d'élément Element::Ecri_bas_inf_element(sort,cas); // en fait ici on sauvegarde la même chose dans tous les cas, par contre la sortie @@ -470,7 +470,7 @@ void ElemThermi::Ecriture_bas_inf(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "ElemThermi::Ecriture_bas_inf(ofstream& sort,const int cas)" + cout << "ElemThermi::Ecriture_bas_inf(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Thermique/ElemThermi4.cc b/Elements/Thermique/ElemThermi4.cc index 2485882..7ed0adc 100755 --- a/Elements/Thermique/ElemThermi4.cc +++ b/Elements/Thermique/ElemThermi4.cc @@ -42,7 +42,7 @@ // affichage dans la sortie transmise, des variables duales "nom" // aux differents points d'integration // dans le cas ou nom est vide, affichage de "toute" les variables -void ElemThermi::VarDualSort(ofstream& sort, Tableau& nom,int ,int cas) +void ElemThermi::VarDualSort(ostream& sort, Tableau& nom,int ,int cas) { if ((cas == 1) || (cas == 2)) { // cas d'une premiere initialisation Tableau tab(5); @@ -162,7 +162,7 @@ void ElemThermi::VarDualSort(ofstream& sort, Tableau& nom,int ,int cas) // liberation des tenseurs intermediaires LibereTenseur(); }; -void ElemThermi::AffDefCont( ofstream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, +void ElemThermi::AffDefCont( ostream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, CoordonneeB& gradTB,Coordonnee& gradT,double& norme_gradT, CoordonneeB& DgradTB,Coordonnee& DgradT,double& norme_dGradT, CoordonneeH& fluxDH,Coordonnee & fluxD,double& norme_flux, @@ -193,7 +193,7 @@ void ElemThermi::AffDefCont( ofstream& sort,CompThermoPhysiqueAbstraite::SaveRes } } }; -void ElemThermi::AffDefCont1D( ofstream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, +void ElemThermi::AffDefCont1D( ostream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, CoordonneeB& gradTB,Coordonnee& gradT,double& norme_gradT, CoordonneeB& DgradTB,Coordonnee& DgradT,double& norme_DGradT, CoordonneeH& fluxDH,Coordonnee & fluxD,double& norme_flux, @@ -265,7 +265,7 @@ void ElemThermi::AffDefCont1D( ofstream& sort,CompThermoPhysiqueAbstraite::SaveR }; -void ElemThermi::AffDefCont2D( ofstream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, +void ElemThermi::AffDefCont2D( ostream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, CoordonneeB& gradTB,Coordonnee& gradT,double& norme_gradT, CoordonneeB& DgradTB,Coordonnee& DgradT,double& norme_DGradT, CoordonneeH& fluxDH,Coordonnee & fluxD,double& norme_flux, @@ -343,7 +343,7 @@ void ElemThermi::AffDefCont2D( ofstream& sort,CompThermoPhysiqueAbstraite::SaveR } }; -void ElemThermi::AffDefCont3D( ofstream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, +void ElemThermi::AffDefCont3D( ostream& sort,CompThermoPhysiqueAbstraite::SaveResul * saveDon, CoordonneeB& gradTB,Coordonnee& gradT,double& norme_gradT, CoordonneeB& DgradTB,Coordonnee& DgradT,double& norme_DGradT, CoordonneeH& fluxDH,Coordonnee & fluxD,double& norme_flux, diff --git a/Elements/Thermique/LesPtIntegThermiInterne.cc b/Elements/Thermique/LesPtIntegThermiInterne.cc index 7742734..b118dfb 100755 --- a/Elements/Thermique/LesPtIntegThermiInterne.cc +++ b/Elements/Thermique/LesPtIntegThermiInterne.cc @@ -118,7 +118,7 @@ int LesPtIntegThermiInterne::DimCoord() const // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesPtIntegThermiInterne::Lecture_base_info (ifstream& ent,const int cas) +void LesPtIntegThermiInterne::Lecture_base_info (istream& ent,const int cas) {switch (cas) { case 1 : // ------- on récupère tout ------------------------- { string nom; ent >> nom; // on ne vérifie pas le nom car on considère que @@ -149,7 +149,7 @@ void LesPtIntegThermiInterne::Lecture_base_info (ifstream& ent,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "LesPtIntegThermiInterne::Lecture_base_info(ifstream& ent,const " + cout << "LesPtIntegThermiInterne::Lecture_base_info(istream& ent,const " << " cas= " << cas << endl; Sortie(1); } @@ -158,7 +158,7 @@ void LesPtIntegThermiInterne::Lecture_base_info (ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesPtIntegThermiInterne::Ecriture_base_info(ofstream& sort,const int cas) +void LesPtIntegThermiInterne::Ecriture_base_info(ostream& sort,const int cas) {switch (cas) { case 1 : // ------- on sauvegarde tout ------------------------- { sort << "\n grandeurs_aux_points_d_integration:" ; @@ -177,7 +177,7 @@ void LesPtIntegThermiInterne::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "LesPtIntegThermiInterne::Ecriture_base_info(ofstream& sort,const int cas)" + cout << "LesPtIntegThermiInterne::Ecriture_base_info(ostream& sort,const int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Elements/Thermique/LesPtIntegThermiInterne.h b/Elements/Thermique/LesPtIntegThermiInterne.h index 53dd96d..c2f9690 100755 --- a/Elements/Thermique/LesPtIntegThermiInterne.h +++ b/Elements/Thermique/LesPtIntegThermiInterne.h @@ -114,11 +114,11 @@ class LesPtIntegThermiInterne // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected: // données protégées diff --git a/Elements/Thermique/PtIntegThermiInterne.cc b/Elements/Thermique/PtIntegThermiInterne.cc index c437729..93f42a2 100755 --- a/Elements/Thermique/PtIntegThermiInterne.cc +++ b/Elements/Thermique/PtIntegThermiInterne.cc @@ -82,7 +82,7 @@ PtIntegThermiInterne& PtIntegThermiInterne::operator= ( const PtIntegThermiInter // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void PtIntegThermiInterne::Lecture_base_info (ifstream& ent,const int ) +void PtIntegThermiInterne::Lecture_base_info (istream& ent,const int ) { // lecture des différents éléments que l'on trouve utiles (pour l'instant) string nom; ent >> nom >> temperature >> nom >> temperature_t; @@ -100,7 +100,7 @@ void PtIntegThermiInterne::Lecture_base_info (ifstream& ent,const int ) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void PtIntegThermiInterne::Ecriture_base_info(ofstream& sort,const int ) +void PtIntegThermiInterne::Ecriture_base_info(ostream& sort,const int ) { // les différents éléments que l'on considère intéressant (pour l'instant) sort << "\n temperature= " << temperature << " temperature_t= " << temperature_t; sort << "\n gradTB= " << gradTB diff --git a/Elements/Thermique/PtIntegThermiInterne.h b/Elements/Thermique/PtIntegThermiInterne.h index 308d1e1..8316a9d 100755 --- a/Elements/Thermique/PtIntegThermiInterne.h +++ b/Elements/Thermique/PtIntegThermiInterne.h @@ -168,11 +168,11 @@ public : // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected : diff --git a/Enumeration/EnumTypeCalcul.cc b/Enumeration/EnumTypeCalcul.cc index 586ca72..eaca994 100644 --- a/Enumeration/EnumTypeCalcul.cc +++ b/Enumeration/EnumTypeCalcul.cc @@ -715,7 +715,7 @@ void Info_commande_type_calcul(UtilLecture& lec,EnumTypeCalcul& typeCalcul,bool& chaine_a_ecrire = " avec " + chaine_a_ecrire; if(chaine_a_ecrire != " ") cout << "\n choix global: " << chaine_a_ecrire << endl; // écriture dans le fichier de commande - ofstream & sort = *(lec.Commande_pointInfo()); // pour simplifier + ostream & sort = *(lec.Commande_pointInfo()); // pour simplifier sort << "\n#-------------------------------" << "\n# definition du type de calcul |" << "\n#-------------------------------" diff --git a/Flambage/LesValVecPropres.cc b/Flambage/LesValVecPropres.cc index e450011..3cb2a6a 100644 --- a/Flambage/LesValVecPropres.cc +++ b/Flambage/LesValVecPropres.cc @@ -30,7 +30,7 @@ #include "LesValVecPropres.h" #include -// s'il manque, il y a un pb dans LesValVecPropres::Affiche(ofstream& sort) const +// s'il manque, il y a un pb dans LesValVecPropres::Affiche(ostream& sort) const @@ -59,7 +59,7 @@ LesValVecPropres& LesValVecPropres::operator= (const LesValVecPropres& a) return (*this); }; // affichage des valeurs et vecteurs propres -void LesValVecPropres::Affiche(ofstream& sort) const +void LesValVecPropres::Affiche(ostream& sort) const { sort << "\n -> valeurs et vecteurs propres associés \n"; sort << " <----------------------> \n"; for (int i=1;i<= VaeP.Taille(); i++) diff --git a/Flambage/LesValVecPropres.h b/Flambage/LesValVecPropres.h index 6b41632..501d99f 100644 --- a/Flambage/LesValVecPropres.h +++ b/Flambage/LesValVecPropres.h @@ -74,7 +74,7 @@ class LesValVecPropres LesValVecPropres& operator= (const LesValVecPropres& a); // affichage des valeurs et vecteurs propres - void Affiche(ofstream& sort) const ; + void Affiche(ostream& sort) const ; private : // VARIABLES PROTEGEES : diff --git a/General/Distribution_CPU.cc b/General/Distribution_CPU.cc index c457cd0..422b0cc 100755 --- a/General/Distribution_CPU.cc +++ b/General/Distribution_CPU.cc @@ -494,7 +494,7 @@ void Distribution_CPU::Affiche() const // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Distribution_CPU::Lecture_base_info(ifstream& ent,const int cas) +void Distribution_CPU::Lecture_base_info(istream& ent,const int cas) { // on récupère le tableau de list : tab_list_maillage_element // on suit exactement la même procédure que pour archive load(ent,cas); @@ -502,7 +502,7 @@ void Distribution_CPU::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Distribution_CPU::Ecriture_base_info(ofstream& sort,const int cas) +void Distribution_CPU::Ecriture_base_info(ostream& sort,const int cas) { // on sauvegarde le tableau de list : tab_list_maillage_element // on suit exactement la même procédure que pour archive save(sort,cas); diff --git a/General/Distribution_CPU.h b/General/Distribution_CPU.h index 4b0b1f0..a95f91d 100755 --- a/General/Distribution_CPU.h +++ b/General/Distribution_CPU.h @@ -152,11 +152,11 @@ class Distribution_CPU // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); private : diff --git a/General/Projet.cc b/General/Projet.cc index f679395..9e23da5 100644 --- a/General/Projet.cc +++ b/General/Projet.cc @@ -815,14 +815,15 @@ void Projet::InitEntreeFichierInfo(string & retour) // démarrage: cas d'une entrée via un fichier .base-info void Projet::InitEntreeFichierBaseInfo(string & retour) { retour = "calcul_elements_finis"; + // les parametres globaux paraGlob = new ParaGlob () ; // construction par défaut int cas = 1; // lecture éventuelle de variables à exporter en grandeur globale varExpor = new VariablesExporter(); - varExpor->Lecture_base_info(*(entreePrinc->Ent_BI()),cas); + varExpor->Lecture_base_info(*(entreePrinc->Ent_BI()),cas); // lecture de la dimension et du type de calcul - paraGlob->Lecture_base_info(*(entreePrinc->Ent_BI()),cas); + paraGlob->Lecture_base_info(*(entreePrinc->Ent_BI()),cas); int dim = paraGlob->Dimension (); // récup de la dimension // def des valeurs des constantes en fonction de la dimension ConstantesTenseur(dim); diff --git a/General/Projet.h b/General/Projet.h index 76ebe6a..f1f6ed1 100644 --- a/General/Projet.h +++ b/General/Projet.h @@ -212,7 +212,7 @@ void SchemaXML_dim(UtilLecture * entreePrinc,Enum_IO_XML enuIO_XML); // sortie du schemaXML: en fonction de enu // ceci pour tous les types de base - void SchemaXML_Type_de_base(ofstream& sort,const Enum_IO_XML enu); + void SchemaXML_Type_de_base(ostream& sort,const Enum_IO_XML enu); void LectureVersion(); // lecture éventuelle de l'indicateur de version void LectureLangue(); // lecture éventuelle de l'indicateur de langue diff --git a/General/Projet2.cc b/General/Projet2.cc index fe3bcc7..82a9e51 100644 --- a/General/Projet2.cc +++ b/General/Projet2.cc @@ -607,7 +607,7 @@ void Projet::Affiche() const // sortie du schemaXML: en fonction de enu // ceci pour tous les types de base -void Projet::SchemaXML_Type_de_base(ofstream& sort,const Enum_IO_XML enu) +void Projet::SchemaXML_Type_de_base(ostream& sort,const Enum_IO_XML enu) { // définition d'une liste de réels if (enu == XML_TYPE_GLOBAUX) // cas de la sortie du type global {sort << "\n " diff --git a/Lecture/UtilLecture.cc b/Lecture/UtilLecture.cc index b6858fd..a365687 100644 --- a/Lecture/UtilLecture.cc +++ b/Lecture/UtilLecture.cc @@ -106,8 +106,16 @@ istream & operator >> (istream & entree, UtilLecture::Position_BI& a) UtilLecture::UtilLecture (int argc, const char * argv[]) : longueur(2500) // longueur maxi du tableau de travail ,nomCourant(),nomRacine(),ptrfich(NULL),tablcar(NULL),tableau(NULL),lec_ent_info(-10) - ,ent_BI(NULL),sort_BI(NULL),ent_PI(NULL),sort_PI(NULL),liste_posi_BI() - ,dernier_increment_lu(0),ptrcommandefich(NULL),ptrschemaXMLfich(NULL) + ,liste_posi_BI() + #ifndef UTILISATION_MPI + ,ent_BI(NULL),sort_BI(NULL),ent_PI(NULL),sort_PI(NULL) + #else + ,ent_MPI_BI(NULL),sort_MPI_BI(NULL),ent_MPI_PI(NULL),sort_MPI_PI(NULL) + ,taille_buffer_Nouvelle_enreg_MPI(10000),buffer_MPI(NULL) + ,lecture_MPI_BI_en_cours(0),taille_actuelle_buffer(0) + ,dernier_posi_dans_buffer(0) + #endif + ,dernier_increment_lu(0),ptrcommandefich(NULL),ptrschemaXMLfich(NULL) ,sort_princ_vrml(NULL),sort_legende_vrml(NULL),sort_princ_maple(NULL) ,sort__temps_cpu(NULL) ,sort_princ_geomview(NULL),sort_legende_geomview(NULL) @@ -123,6 +131,9 @@ istream & operator >> (istream & entree, UtilLecture::Position_BI& a) #endif { bool fr = ParaGlob::Francais(); // pour simplifier + #ifdef UTILISATION_MPI + num_cpu_en_cours_BI = ParaGlob::Monde()->rank(); + #endif // information concernant l'entrée des données if (fr){cout << "\n -- initialisation de l'entree des donnees ";} else {cout << "\n -- initialisation of the data input ";}; @@ -221,7 +232,11 @@ istream & operator >> (istream & entree, UtilLecture::Position_BI& a) tablcar = new char [longueur] ; // def du tableau de travail tableau = new char [longueur] ; // def du tableau intermediaire - tabMultiLignes = new char [longueur]; // def du tableau pour le stockage de plusieurs lignes + tabMultiLignes = new char [longueur]; // def du tableau pour le stockage de plusieurs lignes + #ifndef UTILISATION_MPI + buffer_MPI = new char [taille_buffer_Nouvelle_enreg_MPI]; + #endif + // def du flot d'entree filtree en memoire // utilise pour les conversions de type en lecture #ifndef ENLINUX_STREAM @@ -265,6 +280,10 @@ istream & operator >> (istream & entree, UtilLecture::Position_BI& a) // if (tablcarCVisu != NULL) {delete [] tablcarCVisu;tablcarCVisu=NULL;} //// if (tableauCVisu != NULL) {delete [] tableauCVisu;tableauCVisu=NULL;}; //// if (tabMultiLignes != NULL) {delete [] tabMultiLignes; tabMultiLignes=NULL;}; + #ifndef UTILISATION_MPI + if (buffer_MPI != NULL) delete[] buffer_MPI; + #endif + Fermeture_base_info(); Fermeture_fichier_principal_vrml(); Fermeture_fichier_principal_vrml(); diff --git a/Lecture/UtilLecture.h b/Lecture/UtilLecture.h index eb200ed..dc99459 100644 --- a/Lecture/UtilLecture.h +++ b/Lecture/UtilLecture.h @@ -74,6 +74,14 @@ #include #include "Sortie.h" #include +#ifdef UTILISATION_MPI + #include "mpi.h" + #include + #include + #include + #include + namespace mpi = boost::mpi; +#endif using namespace std; /** @defgroup Goupe_relatif_aux_entrees_sorties @@ -251,10 +259,17 @@ class UtilLecture // -------------- cas de la base d'info ---------------- //fichier base_info dans lequel sont lus les enregistrements // dans le cas ou celui-ci n'est pas ouvert il y a ouverture +#ifndef UTILISATION_MPI ifstream * Ent_BI() ; // et pour l'écriture // dans le cas ou celui-ci n'est pas ouvert il y a ouverture ofstream * Sort_BI() ; + const streampos position_debut_fichier=(ios::beg); +#else + MPI_File * Ent_BI(); // cas MPI + MPI_File * Sort_BI(); // " " + const MPI_Offset position_debut_fichier=0; +#endif // ouverture du fichier base_info après le .info dans le cas d'un restart par exemple // dans le cas ou le fichier est déjà ouvert en lecture ou écriture dans le type demandé // il n'y a aucune action @@ -270,8 +285,16 @@ class UtilLecture // si l'on ne trouve pas de numéro on renvoi un indicateur à false // la méthode renvoie également la position du début de l'incrément // et le numéro trouvé d'incrément +#ifndef UTILISATION_MPI bool Increment_suivant_base_info(streampos& debut_increment,int& inc_lu); - // enregistrement de la position + // positionnement à un offset donné, en écriture + void Sort_BI_Positionnement_offset(const streampos& posi) {Sort_BI()->seekp(posi);}; +#else + bool Increment_suivant_base_info(MPI_Offset& debut_increment,int& inc_lu); + // positionnement à un offset donné, en écriture + void Sort_BI_Positionnement_offset(const MPI_Offset& posi) {MPI_File_seek(*sort_MPI_BI, posi, MPI_SEEK_SET);}; +#endif + // enregistrement de la position // normalement correspond à un début d'incrément void Enregistrement_position_increment_base_info(int incr); // renvoi tous les incréments actuellements enregistré @@ -469,7 +492,11 @@ class UtilLecture friend ostream & operator << (ostream & sort, const Position_BI& a); public : - Position_BI(streampos posi=(ios::beg), int num = 0) : // constructeur + #ifndef UTILISATION_MPI + Position_BI(streampos posi=(ios::beg), int num = 0) : // constructeur + #else + Position_BI(MPI_Offset posi=0, int num = 0) : // constructeur + #endif position (posi), num_incr(num) {}; ~Position_BI() {}; // destructeur @@ -489,7 +516,11 @@ class UtilLecture bool operator != (const Position_BI& a) { return !(*this == a);}; // données + #ifndef UTILISATION_MPI streampos position; // position dans le fichier + #else + MPI_Offset position; + #endif int num_incr; // numéro de l'incrément }; // gestion d'exception pour nouvel_EnregCVisu @@ -518,12 +549,24 @@ class UtilLecture // = 2 ce sera via un serveur base-info // = -11 création d'un fichier de commande // = -12 création du schema XML + #ifndef UTILISATION_MPI fstream * ent_BI ; //fichier base_info dans lequel sont lus les enregistrements fstream * sort_BI ; //fichier base_info de sauvegarde fstream * ent_PI ; //fichier de la liste des pointeurs d'incréments de base info - fstream * sort_PI ; //fichier base_info de sauvegarde - #ifdef UTILISATION_MPI - // cas d'un calcul //, num du cpu en cours dans les opérations + fstream * sort_PI ; // " " + #else + MPI_File * ent_MPI_BI ; // pointeur fichier commun + MPI_File * sort_MPI_BI ; // " " + int taille_buffer_Nouvelle_enreg_MPI; // la taille du buffer pour chaque enreg + char * buffer_MPI; // le tableau du buffer associé + int lecture_MPI_BI_en_cours; // " " =0 le fichier n'est pas ouvert, =1 le buffer n'est pas encore rempli + // = 2 la lecture est en cours et le buffer est rempli + int taille_actuelle_buffer; // " " + int dernier_posi_dans_buffer; // " " + + MPI_File * ent_MPI_PI ; // pointeur fichier liste des pointeurs d'incréments de base info + MPI_File * sort_MPI_PI ; // " " + //, num du cpu en cours dans les opérations int num_cpu_en_cours_BI; // d'i/o sur .BI et .PI #endif // -------cas des temps de calcul ---------------- @@ -570,7 +613,12 @@ class UtilLecture bool EntreeParArgument(int argc, const char * argv[]); // entrée interactive au niveau de la construction de l'objet UtilLecture // dans le cas où il y a eu un pb lec_ent_info=-100, et rien n'est initialisé - void EntreeInteractive(string& ancien,bool& ouverture_ancien); + void EntreeInteractive(string& ancien,bool& ouverture_ancien); + #ifdef UTILISATION_MPI + // ramène un nouvel enregistrement dans le buffer passé en paramètre + // ramène true tant que l'on n'a pas atteind la fin de fichier + bool Nouvelle_enreg_MPI_BI(MPI_File * file,string & buf); + #endif }; diff --git a/Lecture/nouvelle_enreg.cc b/Lecture/nouvelle_enreg.cc index dbc0ffa..aadac64 100644 --- a/Lecture/nouvelle_enreg.cc +++ b/Lecture/nouvelle_enreg.cc @@ -355,7 +355,91 @@ void UtilLecture::Nouvel_enregCvisu () }; - +#ifdef UTILISATION_MPI + // ramène un nouvel enregistrement dans le buffer passé en paramètre + // en utilisant le pointeur individuel de fichier + // ramène true tant que l'on n'a pas atteind la fin de fichier + bool UtilLecture::Nouvelle_enreg_MPI_BI(MPI_File * file,string & buf_ligne) + { + bool fin_fichier = false; // init + + #ifdef MISE_AU_POINT + // petite vérification + if (lecture_MPI_BI_en_cours == 0) + { cout << "\n *** erreur la lecture d'un enregistrement dans le .BI " + << " n'est pas autorisee, lecture_MPI_BI_en_cours == 0 " + << "\n UtilLecture::Nouvelle_enreg_MPI_BI(..."<taille_actuelle_buffer) + {ierr_lecture = MPI_File_read(*file, buffer_MPI, taille_buffer_Nouvelle_enreg_MPI, MPI_CHAR, &status); + // on récupère le nombre d'éléments lus + MPI_Get_count(&status, MPI_CHAR,&taille_actuelle_buffer); + // si le nombre est inférieur à celui demandé, on est arrivé à la fin du fichier + if (taille_actuelle_buffer < taille_buffer_Nouvelle_enreg_MPI) + {fin_fichier = true;} + else {fin_fichier = false;}; + // si la taille du buffer = 0 on ne peut plus lire de caractère et de plus on est à la fin du fichier + dernier_posi_dans_buffer = -1; // au cas où + if (taille_actuelle_buffer == 0) + break; + // sinon on continue avec le nouveau buffer + i = 1; + }; + // si le prochain caractère est '\n', on valide la ligne + buf_ligne += buffer_MPI[i]; + if (buffer_MPI[i] == '\n') + ligne_pas_finie = false; + }; + + //si le buffer n'est pas vidé on positionne la prochaine lecture de caractère + if (!ligne_pas_finie) // la lecture a été ok (on a lue une ligne avec un '\n' à la fin + { dernier_posi_dans_buffer = i; } + else + { // si la ligne n'est pas finie il y a un pb !! + cout << "\n **** erreur de lecture MPI dans le .BI pour le proc "<< num_cpu_en_cours_BI + << " on a atteint la fin de fichier et la ligne courante n'est pas terminee " + << " actuellement on a lue :" << buf_ligne; + Sortie(1); + }; + + // retour de l'indicateur de fin de fichier + return fin_fichier; + }; +#endif + diff --git a/Lecture/utilLecture2.cc b/Lecture/utilLecture2.cc index 8fba042..eba5461 100644 --- a/Lecture/utilLecture2.cc +++ b/Lecture/utilLecture2.cc @@ -54,212 +54,296 @@ void UtilLecture::Ouverture_base_info(string type_entree) // on définit des noms explicites std::string nom_BI(pteurnom); std::string nom_PI(pteurnom); - #ifdef UTILISATION_MPI - // cas d'un calcul //, - // on prend en compte le numéro du CPU - int num_cpu = ParaGlob::Monde()->rank(); - nom_BI += ChangeEntierSTring(num_cpu); - nom_PI += ChangeEntierSTring(num_cpu); - #endif nom_BI += ".BI"; nom_PI += ".PI"; - + #ifdef UTILISATION_MPI + lecture_MPI_BI_en_cours = 0; // initialisation + #endif + + if (type_entree == "lecture") // cas d'une lecture // on regarde si on a déjà une ouverture en écriture si oui on ferme - { if (sort_BI != NULL) - Fermeture_base_info(); - // maintenant on regarde si la lecture est déjà en cours - #ifdef UTILISATION_MPI - // cas d'un calcul //, et que l'on a une lecture en cours - // on regarde si on a changé de CPU - // si oui, on ferme tout - if (ent_BI != NULL) - {if (num_cpu_en_cours_BI != num_cpu) - {Fermeture_base_info(); - // on met à jour le numéro en cours - num_cpu_en_cours_BI = num_cpu; - }; - }; + //===1) cas du fichier BI === + { + #ifndef UTILISATION_MPI + { + //===1) cas du fichier BI === + if (sort_BI != NULL) + Fermeture_base_info(); + // maintenant on regarde si la lecture est déjà en cours + // si pas de fichier ouvert, on ouvre + if (ent_BI == NULL) + { //ent_BI = new fstream(strcat(fileName,".BI"), ios::out | ios::in); + ent_BI = new fstream(nom_BI.c_str(), ios::out | ios::in); + if(!(ent_BI->is_open())) + // le fichier ne peut être ouvert, message d'erreur + { cout << "\n erreur en ouverture pour la lecture du fichier " << nom_BI << "\n" + << " UtilLecture::Ouverture_base_info() " << endl; + Sortie(1); + }; + }; + } + #else + { if (sort_MPI_BI != NULL) + Fermeture_base_info(); + // maintenant on regarde si la lecture est déjà en cours + // si pas de fichier ouvert, on ouvre + if (ent_MPI_BI == NULL) + { int ierr_ouverture_BI = MPI_File_open((*ParaGlob::Monde()),nom_BI.c_str(), MPI_MODE_CREATE | MPI_MODE_RDWR, MPI_INFO_NULL, ent_MPI_BI); + if((!ierr_ouverture_BI) && (num_cpu_en_cours_BI == 0)) + // le fichier ne peut être ouvert, message d'erreur + { cout << "\n ***erreur en ouverture pour la lecture du fichier " << nom_BI + << "\n proc: " << num_cpu_en_cours_BI + << "\n UtilLecture::Ouverture_base_info() " << endl; + Sortie(1); + }; + }; + // sinon ok, on rend exploitable la méthode Nouvelle_enreg_MPI_BI + lecture_MPI_BI_en_cours = 1; // on peut lire avec Nouvelle_enreg_MPI_BI + }; #endif - // si pas de fichier ouvert, on ouvre - if (ent_BI == NULL) - { //ent_BI = new fstream(strcat(fileName,".BI"), ios::out | ios::in); - ent_BI = new fstream(nom_BI.c_str(), ios::out | ios::in); - if(!(ent_BI->is_open())) - // le fichier ne peut être ouvert, message d'erreur - { cout << "\n erreur en ouverture pour la lecture du fichier " << nom_BI << "\n" - << " UtilLecture::Ouverture_base_info() " << endl; - Sortie(1); - }; - // cas du fichier de pointeur, traitement presque analogue -// strcpy(fileName, pteurnom); -// ent_PI = new fstream(strcat(fileName,".PI"), ios::out | ios::in); - ent_PI = new fstream(nom_PI.c_str(), ios::out | ios::in); - if(!(ent_PI->is_open())) - // le fichier ne peut être ouvert, message d'erreur - { cout << "\n erreur en ouverture pour la lecture du fichier " << nom_PI << "\n" - << " le fichier de pointeur ne peut etre lu, on essaie de faire uniquement avec le .BI " - << endl; - ent_PI = NULL; - }; - bool positionPI = false; // pour de la gestion de cas - if (ent_PI!=NULL) // si le fichier n'est pas vide - { // et on récupère les pointeurs d'incrément - string toto;int nb_position; - // on lit la première ligne - (*ent_PI) >> toto >> nb_position; - // dans le cas ou il n'y a pas d'erreur - // on effectue la lecture des positions si seulement - // le nombre de position actuellement en service est différent - if (ent_PI->rdstate() == 0) - {// si le nombre de position actuelle est non valide, on lit - if (liste_posi_BI.size() != nb_position) - { // on efface les positions actuelles - liste_posi_BI.clear(); - // lecture des positions - for (int i=1;i<= nb_position;i++) - { Position_BI truc; - (*ent_PI) >> truc; - liste_posi_BI.push_back(truc); - }; - }; - positionPI = true; - } - } - // si les positions n'ont pas été validé, on essaie de les recréer - if (!positionPI) - // le fichier de pointeur n'est pas exploitable - // on redéfinit par lecture le tableau de pointeur à partir du .BI - { cout << "\n attention, le fichier de pointeur .PI n'est pas exploitable " - << " \n on va donc essayer de retrouver les positions des increments " - << " dans .BI mais ce sera plus long !! " << endl; - if (ent_PI != NULL) {ent_PI->close();ent_PI = NULL;}; - // on efface les positions actuelles - liste_posi_BI.clear(); - // on se positionne au premier incrément et si c'est ok on continue - int incre = 0; streampos debut_increment(0); - if (Positionnement_base_info(incre)) - { // enregistrement et bouclage - Position_BI truc(debut_increment,incre); - liste_posi_BI.push_back(truc); - while (Increment_suivant_base_info(debut_increment,incre)) - { // dans la fonction il y a l'enregistrement dans la liste - // d'où on ne fait rien ici - }; - // maintenant on se repositionne au début du fichier pour le BI - ent_BI->clear(); - ent_BI->seekg(ios::beg); - dernier_increment_lu = 0; - // on sauvegarde les positions pour une prochaine utilisation -// strcpy(fileName, pteurnom); -// sort_PI = new fstream(strcat(fileName,".PI"), ios::out | ios::in); - sort_PI = new fstream(nom_PI.c_str(), ios::out | ios::in); - if(!(sort_PI->is_open())) - // le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre - { //sort_PI = new fstream(fileName, ios::out | ios::ate); - sort_PI = new fstream(nom_PI.c_str(), ios::out | ios::in); - if(!(sort_PI->is_open())) - // le fichier ne peut être ouvert, message d'erreur - { cout << "\n erreur en ouverture pour la lecture du fichier " << nom_PI << "\n" - << " UtilLecture::Ouverture_base_info() " << endl; - Sortie(1); - }; - }; - list::iterator iter,iter_fin = liste_posi_BI.end(); - (*sort_PI) << "liste_des_positions_et_de_pointeur_dans_base_info,_taille_: " - << liste_posi_BI.size() << "\n"; - for (iter = liste_posi_BI.begin();iter != iter_fin;iter++) - (*sort_PI) << (*iter) << "\n"; - (*sort_PI) << endl; - sort_PI->close();sort_PI=NULL; - }; - } - } + // === cas du fichier de pointeur, traitement presque analogue === + bool positionPI = false; // pour de la gestion de cas - } + #ifndef UTILISATION_MPI + { ent_PI = new fstream(nom_PI.c_str(), ios::out | ios::in); + if(!(ent_PI->is_open())) + // le fichier ne peut être ouvert, message d'erreur + { ent_PI = NULL; + cout << "\n erreur en ouverture pour la lecture du fichier " << nom_PI << "\n" + << " le fichier de pointeur ne peut etre lu, on essaie de faire uniquement avec le .BI " + << endl; + }; + } + #else + // en MPI seule le proc 0 s'occupe du .PI car c'est lui qui transmettra les offsets finaux aux proc i + if(num_cpu_en_cours_BI == 0) + { int ierr_ouverture_PI = MPI_File_open((*ParaGlob::Monde()),nom_BI.c_str(),MPI_MODE_RDWR, MPI_INFO_NULL, ent_MPI_PI); + if(!ierr_ouverture_PI) + { ent_MPI_PI = NULL; + cout << "\n erreur en ouverture pour la lecture du fichier " << nom_PI + << "\n proc: " << num_cpu_en_cours_BI + << "\n le fichier de pointeur ne peut etre lu, on essaie de faire uniquement avec le .BI " + << endl; + }; + }; + #endif + + #ifdef UTILISATION_MPI + // on crée un flux sur le tableau de caractères: ----> on redéfinit ent_PI en local + istrstream * ent_PI = NULL ; // init + if(num_cpu_en_cours_BI == 0) + {// cas particulier de la lecture en MPI io + if (ent_MPI_PI!=NULL) + {// on récupère en une seule étape le contenu du fichier, + // a priori la taille du buffer nécessaire n'est pas grande + MPI_Offset filesize; + int taille_fichier_enOctet = MPI_File_get_size(*ent_MPI_PI, &filesize); /* in bytes */ + char * buffer_car = new char [taille_fichier_enOctet] ; // def du tableau de travail + MPI_Status status; + MPI_File_read(*ent_MPI_PI, buffer_car, taille_fichier_enOctet, MPI_CHAR, &status); + // on crée un flux sur le tableau de caractères: ----> on redéfinit ent_PI en local + istrstream * ent_PI = new istrstream(buffer_car,taille_fichier_enOctet) ; + }; + }; + #endif + // on lit les positions + if (ent_PI!=NULL) // si le fichier n'est pas vide + { // et on récupère les pointeurs d'incrément + string toto;int nb_position; + // on lit la première ligne + (*ent_PI) >> toto >> nb_position; + // dans le cas ou il n'y a pas d'erreur + // on effectue la lecture des positions si seulement + // le nombre de position actuellement en service est différent + if (ent_PI->rdstate() == 0) + {// si le nombre de position actuelle est non valide, on lit + if (liste_posi_BI.size() != nb_position) + { // on efface les positions actuelles + liste_posi_BI.clear(); + // lecture des positions + for (int i=1;i<= nb_position;i++) + { Position_BI truc; + (*ent_PI) >> truc; + liste_posi_BI.push_back(truc); + }; + }; + positionPI = true; + } + }; + #ifdef UTILISATION_MPI + if ((num_cpu_en_cours_BI == 0) && (ent_PI!=NULL)) + delete ent_PI; // on supprime le flux intermédiaire + #endif + // si les positions n'ont pas été validé, on essaie de les recréer + if (!positionPI) + // le fichier de pointeur n'est pas exploitable + // on redéfinit par lecture le tableau de pointeur à partir du .BI + { cout << "\n attention, le fichier de pointeur .PI n'est pas exploitable " + << " \n on va donc essayer de retrouver les positions des increments " + << " dans .BI mais ce sera plus long !! " << endl; + #ifndef UTILISATION_MPI + if (ent_PI != NULL) {ent_PI->close();ent_PI = NULL;}; + streampos debut_increment(0); + #else + if (ent_MPI_PI != NULL) {MPI_File_close(ent_MPI_PI);ent_MPI_PI = NULL;}; + MPI_Offset debut_increment(0); + #endif + // on efface les positions actuelles + liste_posi_BI.clear(); + // on se positionne au premier incrément et si c'est ok on continue + int incre = 0; + if (Positionnement_base_info(incre)) + { // enregistrement et bouclage + Position_BI truc(debut_increment,incre); + liste_posi_BI.push_back(truc); + while (Increment_suivant_base_info(debut_increment,incre)) + { // dans la fonction il y a l'enregistrement dans la liste + // d'où on ne fait rien ici + }; + }; + // maintenant on se repositionne au début du fichier pour le BI + #ifndef UTILISATION_MPI + ent_BI->clear(); + ent_BI->seekg(ios::beg); + #else + MPI_File_seek(*ent_MPI_BI, 0, MPI_SEEK_SET); + #endif + dernier_increment_lu = 0; + #ifndef UTILISATION_MPI + {sort_PI = new fstream(nom_PI.c_str(), ios::out | ios::in); + if(!(sort_PI->is_open())) + // le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre + { sort_PI = new fstream(nom_PI.c_str(), ios::out | ios::in); + if(!(sort_PI->is_open())) + // le fichier ne peut être ouvert, message d'erreur + { cout << "\n erreur en ouverture pour l'ecriture du fichier " << nom_PI << "\n" + << " UtilLecture::Ouverture_base_info() " << endl; + Sortie(1); + }; + + list::iterator iter,iter_fin = liste_posi_BI.end(); + (*sort_PI) << "liste_des_positions_et_de_pointeur_dans_base_info,_taille_: " + << liste_posi_BI.size() << "\n"; + for (iter = liste_posi_BI.begin();iter != iter_fin;iter++) + (*sort_PI) << (*iter) << "\n"; + (*sort_PI) << endl; + sort_PI->close();sort_PI=NULL; + }; + }; + #else + {int ierr_ouverture_PI = MPI_File_open((*ParaGlob::Monde()),nom_BI.c_str(),MPI_MODE_RDWR, MPI_INFO_NULL, sort_MPI_PI); + if(!ierr_ouverture_PI) + // le fichier ne peut être ouvert, message d'erreur + { cout << "\n erreur en ouverture pour l'ecriture du fichier " << nom_PI << "\n" + << " UtilLecture::Ouverture_base_info() " << endl; + Sortie(1); + }; + // sinon on sort les positions + // on crée un flux intermédiaire pour stocker dans un buffer les infos + std::ostringstream buf2(std::ios_base::out); + buf2 << "liste_des_positions_et_de_pointeur_dans_base_info,_taille_: " + << liste_posi_BI.size() << "\n"; + list::iterator iter,iter_fin = liste_posi_BI.end(); + for (iter = liste_posi_BI.begin();iter != iter_fin;iter++) + buf2 << (*iter) << "\n"; + buf2 << endl; + // le buffer du stream n'est pas pérenne il faut le récupérer + string buf_inter = buf2.str(); // on récupère le buffer + int taille_buf = buf_inter.size(); + MPI_Status *status; // pour le retour + int retour = MPI_File_write(*sort_MPI_PI,buf_inter.c_str(),taille_buf,MPI_CHAR,status); + MPI_File_close(sort_MPI_PI); + sort_MPI_PI=NULL; + }; + #endif + }; // fin du test if (!positionPI) + } else if (type_entree == "ecriture") // cas d'une ecriture // on regarde si on a déjà une ouverture en lecture si oui on ferme - { if (ent_BI != NULL) + { + #ifndef UTILISATION_MPI + if (ent_BI != NULL) + #else + lecture_MPI_BI_en_cours = 0; // on ne peut plus utiliser Nouvelle_enreg_MPI_BI + if (ent_MPI_BI != NULL) + #endif Fermeture_base_info(); - #ifdef UTILISATION_MPI - // cas d'un calcul //, et que l'on a une écriture en cours - // on regarde si on a changé de CPU - // si oui, on ferme tout - if (sort_BI != NULL) - {if (num_cpu_en_cours_BI != num_cpu) - {Fermeture_base_info(); - // on met à jour le numéro en cours - num_cpu_en_cours_BI = num_cpu; + // maintenant on regarde si l'écriture est déjà en cours si oui on ne fait rien + // sinon on ouvre et on se place à la fin + #ifndef UTILISATION_MPI + if (sort_BI == NULL) + { sort_BI = new fstream(nom_BI.c_str(), ios::out | ios::in | ios::ate); + if(!(sort_BI->is_open())) + // le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre + { sort_BI = new fstream(nom_BI.c_str(), ios::out | ios::ate); + if(!(sort_BI->is_open())) + // le fichier ne peut être ouvert, message d'erreur + { cout << "\n erreur en ouverture pour l'ecriture du fichier " << nom_BI << "\n" + << " UtilLecture::Ouverture_base_info() " << endl; + Sortie(1); + } }; }; - #endif - - // maintenant on regarde si la lecture est déjà en cours si oui on ne fait rien - // sinon on ouvre et on se place à la fin - if (sort_BI == NULL) - { sort_BI = new fstream(nom_BI.c_str(), ios::out | ios::in | ios::ate); - if(!(sort_BI->is_open())) - // le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre - { sort_BI = new fstream(nom_BI.c_str(), ios::out | ios::ate); - if(!(sort_BI->is_open())) - // le fichier ne peut être ouvert, message d'erreur - { cout << "\n erreur en ouverture pour la lecture du fichier " << nom_BI << "\n" - << " UtilLecture::Ouverture_base_info() " << endl; - Sortie(1); - } - } - // même traitement pour le fichier de pointeur d'incrément - // qui est cependant systématiquement mis à 0, on écrit du début - sort_PI = new fstream(nom_PI.c_str(), ios::out | ios::in); - if(!(sort_PI->is_open())) + #else + if (sort_MPI_BI == NULL) + { int ierr_ouverture_BI = MPI_File_open((*ParaGlob::Monde()),nom_BI.c_str(), MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_APPEND, MPI_INFO_NULL, sort_MPI_BI); + if((!ierr_ouverture_BI) && (num_cpu_en_cours_BI == 0)) + // le fichier ne peut être ouvert, message d'erreur + { cout << "\n erreur en ouverture pour l'ecriture du fichier " << nom_BI << "\n" + << " UtilLecture::Ouverture_base_info() " << endl; + Sortie(1); + }; + }; + #endif + + // === même traitement pour le fichier de pointeur d'incrément === + // qui est cependant systématiquement mis à 0, on écrit du début + #ifndef UTILISATION_MPI + sort_PI = new fstream(nom_PI.c_str(), ios::out | ios::in); + if(!(sort_PI->is_open())) // le fichier ne peut être ouvert, il n'existe pas donc on l'ouvre { sort_PI = new fstream(nom_PI.c_str(), ios::out | ios::ate); if(!(sort_PI->is_open())) // le fichier ne peut être ouvert, message d'erreur - { cout << "\n erreur en ouverture pour la lecture du fichier " << nom_PI << "\n" + { cout << "\n erreur en ouverture pour l'ecriture du fichier " << nom_PI << "\n" << " UtilLecture::Ouverture_base_info() " << endl; Sortie(1); - } - } - } - } + }; + }; + #else + // en MPI seule le proc 0 s'occupe du .PI car c'est lui qui transmettra les offsets finaux aux proc i + if(num_cpu_en_cours_BI == 0) + { int ierr_ouverture_PI = MPI_File_open((*ParaGlob::Monde()),nom_BI.c_str(),MPI_MODE_RDWR | MPI_MODE_APPEND, MPI_INFO_NULL, sort_MPI_PI); + if(!ierr_ouverture_PI) + { ent_MPI_PI = NULL; + cout << "\n erreur en ouverture pour l'ecriture du fichier " << nom_PI << "\n" + << " UtilLecture::Ouverture_base_info() " << endl; + Sortie(1); + }; + }; + #endif + + + }; // fin du cas de l'écriture - // essai - /* // essai - fstream * toto; - toto = new fstream("toto", ios::out | ios::in ); - toto->clear(); - (*toto) << "truc \n";(*toto) << "tric"; - // positionnement au début du fichier - toto->seekp(0,ios::beg); - string titi; - (*toto) >> titi; - // récup de l'adresse - streampos adresse = toto->tellp(); - // ouverture d'un stream en écriture er positionnement - fstream * toutou; - toto->seekp(0,ios::beg); - toto->close (); - toutou = new fstream("toto",ios::out | ios::in | ios::ate); - toutou->seekp(adresse); - // (*toutou) >> titi; - (*toutou) << "\nfin\n"; - toutou->close(); */ - }; + }; // fermeture du fichier base_info void UtilLecture::Fermeture_base_info() - { if (ent_BI != NULL) + { + #ifndef UTILISATION_MPI + if (ent_BI != NULL) {// cas du fichier ouvert en lecture delete ent_BI; ent_BI = NULL; if(ent_PI != NULL) delete ent_PI; ent_PI = NULL; - } + }; if (sort_BI != NULL) {// cas du fichier ouvert en écriture delete sort_BI; @@ -267,7 +351,7 @@ void UtilLecture::Fermeture_base_info() // on sauvegarde le tableau de pointeur d'incrément sort_PI->seekp( ios::beg); list::iterator iter,iter_fin = liste_posi_BI.end(); - (*sort_PI) << "liste_des_positions_et_de_pointeur_dans_base_info,_taille_: " + (*sort_PI) << "liste_des_positions_et_de_pointeur_dans_base_info,_taille_: " << liste_posi_BI.size() << "\n"; for (iter = liste_posi_BI.begin();iter != iter_fin;iter++) (*sort_PI) << (*iter) << "\n"; @@ -280,36 +364,93 @@ void UtilLecture::Fermeture_base_info() delete sort_PI; sort_PI = NULL; } + #else + lecture_MPI_BI_en_cours = 0; // on ne peut plus utiliser Nouvelle_enreg_MPI_BI + if (ent_MPI_BI != NULL) + {// cas du fichier ouvert en lecture + MPI_File_close(ent_MPI_BI); + ent_MPI_BI=NULL; + MPI_File_close(ent_MPI_PI); + ent_MPI_PI=NULL; + }; + if (sort_MPI_BI != NULL) + {// cas du fichier ouvert en écriture + MPI_File_close(sort_MPI_BI); + sort_MPI_BI=NULL; + // on sauvegarde le tableau de pointeur d'incrément + MPI_File_seek(*sort_MPI_PI, 0, MPI_SEEK_SET); + + // on crée un flux intermédiaire pour stocker dans un buffer les infos + std::ostringstream buf2(std::ios_base::out); + buf2 << "liste_des_positions_et_de_pointeur_dans_base_info,_taille_: " + << liste_posi_BI.size() << "\n"; + list::iterator iter,iter_fin = liste_posi_BI.end(); + for (iter = liste_posi_BI.begin();iter != iter_fin;iter++) + buf2 << (*iter) << "\n"; + buf2 << endl; + // le buffer du stream n'est pas pérenne il faut le récupérer + string buf_inter = buf2.str(); // on récupère le buffer + int taille_buf = buf_inter.size(); + MPI_Status *status; // pour le retour + + int retour = MPI_File_write(*sort_MPI_PI,buf_inter.c_str(),taille_buf,MPI_CHAR,status); + // fermeture du fichier + MPI_File_close(sort_MPI_PI); + sort_MPI_PI=NULL; + } + #endif }; //fichier base_info dans lequel sont lus les enregistrements -ifstream * UtilLecture::Ent_BI() +#ifndef UTILISATION_MPI + ifstream * UtilLecture::Ent_BI() { if (ent_BI == NULL) +#else + MPI_File * UtilLecture::Ent_BI() // cas MPI + { if (ent_MPI_BI == NULL) +#endif { // cas ou le fichier n'est pas ouvert on l'ouvre Ouverture_base_info("lecture"); - } - - - - return (ifstream*) ent_BI; - }; + } +#ifndef UTILISATION_MPI + return (ifstream*) ent_BI; +#else + return ent_MPI_BI; +#endif + }; + // et pour l'écriture -ofstream * UtilLecture::Sort_BI() +#ifndef UTILISATION_MPI + ofstream * UtilLecture::Sort_BI() { if (sort_BI == NULL) +#else + MPI_File * UtilLecture::Sort_BI() + { if (sort_MPI_BI == NULL) +#endif { // cas ou le fichier n'est pas ouvert on l'ouvre Ouverture_base_info("ecriture"); - } + } +#ifndef UTILISATION_MPI return (ofstream*) sort_BI; +#else + return sort_MPI_BI; +#endif } ; // positionnement dans le fichier d'entrès au niveau d'un numéro d'incrément // si l'on ne trouve pas le numéro on renvoi un indicateur à false bool UtilLecture::Positionnement_base_info(int inc_voulu) - { streampos debut_increment(0); + { // tout d'abord on vérifie que le fichier base_info est disponible en lecture // sinon on l'ouvre en lecture + #ifndef UTILISATION_MPI + streampos debut_increment(0); if (ent_BI == NULL) + #else + MPI_Offset debut_increment(0); + if (ent_MPI_BI == NULL) + #endif Ouverture_base_info("lecture"); // --- on ne fait pas une recherche en boucle, comme commencé dans les lignes commentées qui suivent @@ -319,102 +460,180 @@ bool UtilLecture::Positionnement_base_info(int inc_voulu) // bool debut = true; // if (std::ios::beg != ( ent_BI->tellg())) debut = false; + bool retour = false; // init par défaut // on regarde si l'incrément demandé n'a pas déjà été enregistré + #ifndef UTILISATION_MPI Position_BI pos_ent(ios::beg,inc_voulu); + #else + Position_BI pos_ent(debut_increment,inc_voulu); + #endif list ::iterator iposi = find(liste_posi_BI.begin(),liste_posi_BI.end(),pos_ent); if (iposi != liste_posi_BI.end()) + #ifndef UTILISATION_MPI // dans le cas ou l'incrément existe, on se positionne à l'adresse mémorisée - {ent_BI->clear(); // on remet à 0 les bits de contrôle car si lors d'une précédente lecture + { ent_BI->clear(); // on remet à 0 les bits de contrôle car si lors d'une précédente lecture // on est par exemple arrivée à la fin du fichier, la fonction seekg ne fonctionnera // pas !! car le bit de eof est activé - ent_BI->seekg((*iposi).position, ios::beg); - }; + ent_BI->seekg((*iposi).position, ios::beg); + // maintenant on lit + string toto; int titi; int inc; bool inc_trouve = false; + // def d'un tableau d'entrée en flot d'entrée pour faire de la lecture non formaté + char * tableau; int longueur = 250; + tableau = new char [longueur] ; // def du tableau intermediaire + istrstream * intar; + // on définit une position intermédiaire dans le fichier pour bien se positionner + // pour l'écriture ensuite éventuelle des incréments + streampos position_inter=0; + // lecture tant que l'on n'a pas atteint la fin du fichier + do + { // tout d'abord on mémorise l'ancienne position et on récupère la nouvelle + debut_increment = position_inter; + position_inter = ent_BI->tellg(); + // si la ligne est la bonne debut_increment sera positionné sur le début + // de la ligne qui contiend des ==== + + ent_BI->getline(tableau,longueur,'\n'); // lecture d'une ligne dans le fichier + if (strstr(tableau,"INCREMENT_DE_CHARGE_:")!=NULL) + { // on repositionne le flot au debut du tableau de carractere + // ouverture du flot a la longueur sans blanc + intar = new istrstream(tableau,short(strlen (tableau))) ; + (*intar) >> toto >> inc; + if (inc == inc_voulu) + // ok on a l'incrément voulu + // fin de la préparation de la lecture pour l'incrément + {(*intar) >> toto >> titi + >> toto ; + inc_trouve = true; + } + delete intar; + } + // test pour vérifier l'intégrité du flot + if (ent_BI->rdstate() != 0) + // si l'on est arrivé à la fin du fichier il n'y a rien à faire + // sinon on remet à flot le flot (cas par exemple d'entier au lieu de caractère)! + if (!(ent_BI->eof())) + ent_BI->clear(); + } + while ((!(ent_BI->eof()))&& (!inc_trouve)); + delete[] tableau; + + if (!inc_trouve) + retour = false; + else + { // on passe la ligne des === + (*ent_BI) >> toto; + // on met à jour la variable dernier_increment_lu + dernier_increment_lu = inc_voulu; + retour = true; + }; + + }; + #else + {// on se positionne à l'offset voulu + MPI_File_seek(*ent_MPI_BI, (*iposi).position, MPI_SEEK_SET); + // on récupère une ligne dans .BI + string buf_ligne; + string indic_string("INCREMENT_DE_CHARGE_:"); + string toto;int inc; bool inc_trouve = false; + bool pas_fin_fichier = false; // init + + // lecture tant que l'on n'a pas atteint la fin du fichier + do + { // lecture d'une ligne dans le fichier + pas_fin_fichier = Nouvelle_enreg_MPI_BI(ent_MPI_BI,buf_ligne); + std::size_t found = buf_ligne.find(indic_string); + if (found!=std::string::npos) + { // on a trouvé l'indicateur "INCREMENT_DE_CHARGE_:" + // on lit l'incrément + std::istringstream inbuf(buf_ligne); + inbuf >> toto >> inc; + if (inc == inc_voulu) + // ok on a l'incrément voulu + // fin de la préparation de la lecture pour l'incrément + inc_trouve = true; + } + + } while (pas_fin_fichier && (!inc_trouve)); + + if (!inc_trouve) + retour = false; + else + { // on passe la ligne des === + pas_fin_fichier = Nouvelle_enreg_MPI_BI(ent_MPI_BI,buf_ligne); + // on met à jour la variable dernier_increment_lu + dernier_increment_lu = inc_voulu; + retour = true; + }; + }; + #endif + + // retour unique + return retour; - // maintenant on lit - string toto; int titi; int inc; bool inc_trouve = false; - // def d'un tableau d'entrée en flot d'entrée pour faire de la lecture non formaté - char * tableau; int longueur = 250; - tableau = new char [longueur] ; // def du tableau intermediaire - istrstream * intar; - // on définit une position intermédiaire dans le fichier pour bien se positionner - // pour l'écriture ensuite éventuelle des incréments - streampos position_inter=0; - // lecture tant que l'on n'a pas atteint la fin du fichier - do - { // tout d'abord on mémorise l'ancienne position et on récupère la nouvelle - debut_increment = position_inter; - position_inter = ent_BI->tellg(); - // si la ligne est la bonne debut_increment sera positionné sur le début - // de la ligne qui contiend des ==== - - ent_BI->getline(tableau,longueur,'\n'); // lecture d'une ligne dans le fichier - if (strstr(tableau,"INCREMENT_DE_CHARGE_:")!=NULL) - { // on repositionne le flot au debut du tableau de carractere - // ouverture du flot a la longueur sans blanc - intar = new istrstream(tableau,short(strlen (tableau))) ; - (*intar) >> toto >> inc; - if (inc == inc_voulu) - // ok on a l'incrément voulu - // fin de la préparation de la lecture pour l'incrément - {(*intar) >> toto >> titi - >> toto ; - inc_trouve = true; - } - delete intar; - } - // test pour vérifier l'intégrité du flot - if (ent_BI->rdstate() != 0) - // si l'on est arrivé à la fin du fichier il n'y a rien à faire - // sinon on remet à flot le flot (cas par exemple d'entier au lieu de caractère)! - if (!(ent_BI->eof())) - ent_BI->clear(); - } - while ((!(ent_BI->eof()))&& (!inc_trouve)); - delete[] tableau; - - if (!inc_trouve) - return false; - else - { // on passe la ligne des === - (*ent_BI) >> toto; - // on met à jour la variable dernier_increment_lu - dernier_increment_lu = inc_voulu; - return true; - }; }; // positionnement dans le fichier d'entrès au niveau du numéro d'incrément suivant // si l'on ne trouve pas de numéro on renvoi un indicateur à false // la méthode renvoie également la position du début de l'incrément // et le numéro trouvé d'incrément -bool UtilLecture::Increment_suivant_base_info(streampos& debut_increment,int& inc_lu) - { // tout d'abord on vérifie que le fichier base_info est disponible en lecture +#ifndef UTILISATION_MPI + bool UtilLecture::Increment_suivant_base_info(streampos& debut_increment,int& inc_lu) + { // tout d'abord on vérifie que le fichier base_info est disponible en lecture // sinon on l'ouvre en lecture if (ent_BI == NULL) +#else + bool UtilLecture::Increment_suivant_base_info(MPI_Offset& debut_increment,int& inc_lu) + { // tout d'abord on vérifie que le fichier base_info est disponible en lecture + // sinon on l'ouvre en lecture + if (ent_MPI_BI == NULL) +#endif Ouverture_base_info("lecture"); // on regarde si dans la liste des incréments enregistrés, la position du suivant // s'il existe Position_BI pos_int(ios::beg,dernier_increment_lu); list ::iterator iposi = find(liste_posi_BI.begin(),liste_posi_BI.end(),pos_int); - // iposi représente la position du dernier incrément enregistré + // iposi représente la position du dernier incrément enregistré + + #ifndef UTILISATION_MPI if (iposi != liste_posi_BI.end()) // cas ou l'incrément existe, on prend le suivant {list ::iterator iposa = iposi; // sauvegarde iposi++; // on vérifie qu'il existe et dans ce cas on se positionne correctement if (iposi != liste_posi_BI.end()) - ent_BI->seekg((*iposi).position, ios::beg); + {ent_BI->seekg((*iposi).position, ios::beg);} else - // sinon on se met à la dernière position - ent_BI->seekg((*iposa).position, ios::beg); + // sinon on se met à la dernière position lue + {ent_BI->seekg((*iposa).position, ios::beg);}; } else // si c'était le dernier enregistré on se met à la dernière position // au cas ou le fichier de pointeur n'est pas complet - ent_BI->seekg(pos_int.position, ios::beg); - // maintenant on lit + {ent_BI->seekg(pos_int.position, ios::beg);}; + #else + if (iposi != liste_posi_BI.end()) + // cas ou l'incrément existe, on prend le suivant + {list ::iterator iposa = iposi; // sauvegarde + iposi++; + // on vérifie qu'il existe et dans ce cas on se positionne correctement + if (iposi != liste_posi_BI.end()) + MPI_File_seek(*ent_MPI_BI, (*iposi).position, MPI_SEEK_SET); + else + // sinon on se met à la dernière position lue + MPI_File_seek(*ent_MPI_BI, (*iposa).position, MPI_SEEK_SET); + } + else + // si c'était le dernier enregistré on se met à la dernière position + // au cas ou le fichier de pointeur n'est pas complet + {MPI_File_seek(*ent_MPI_BI, pos_int.position, MPI_SEEK_SET);}; + #endif + + + bool retour = false; // init par défaut + // maintenant on lit + #ifndef UTILISATION_MPI string toto; bool inc_trouve = false; // def d'un tableau d'entrée en flot d'entrée pour faire de la lecture non formaté char * tableau; int longueur = 250; @@ -452,14 +671,54 @@ bool UtilLecture::Increment_suivant_base_info(streampos& debut_increment,int& in while ((!(ent_BI->eof()))&& (!inc_trouve)); delete[] tableau; // dans le cas où on n'a pas trouvé de bon incrément - if (!inc_trouve) + if (!inc_trouve) { inc_lu = -1; - return false; + retour= false; } - else + else { // on passe la ligne des === (*ent_BI) >> toto; - // on enregistre la position dans la liste de position + }; + #else + // préparation + string buf_ligne; + string indic_string("INCREMENT_DE_CHARGE_:"); + string toto;int inc; bool inc_trouve = false; + bool pas_fin_fichier = false; // init + // on définit une position intermédiaire dans le fichier pour bien se positionner + // pour l'écriture ensuite éventuelle des incréments + MPI_Offset position_inter=0; + MPI_File_get_position(*ent_MPI_BI, &position_inter); + // lecture tant que l'on n'a pas atteint la fin du fichier + do + { // tout d'abord on mémorise l'ancienne position et on récupère la nouvelle + debut_increment = position_inter; + MPI_File_get_position(*ent_MPI_BI, &position_inter); + // lecture d'une ligne dans le fichier + pas_fin_fichier = Nouvelle_enreg_MPI_BI(ent_MPI_BI,buf_ligne); + std::size_t found = buf_ligne.find(indic_string); + if (found!=std::string::npos) + { // on a trouvé l'indicateur "INCREMENT_DE_CHARGE_:" + // on lit l'incrément + std::istringstream inbuf(buf_ligne); + inbuf >> toto >> inc_lu; + // le nouvel incrément n'est valide que s'il est différent de l'ancien + if (inc_lu != dernier_increment_lu) + // ok on a récupéré un début d'incrément + inc_trouve = true; + } + } while (pas_fin_fichier && (!inc_trouve)); + + if (!inc_trouve) + retour = false; + else + { // on passe la ligne des === + pas_fin_fichier = Nouvelle_enreg_MPI_BI(ent_MPI_BI,buf_ligne); + }; + #endif + + if (inc_trouve) + { // on enregistre la position dans la liste de position // on regarde si l'incrément demandé n'a pas déjà été enregistré Position_BI pos_ent(debut_increment,inc_lu); list ::iterator iposi_end = liste_posi_BI.end(); @@ -485,23 +744,29 @@ bool UtilLecture::Increment_suivant_base_info(streampos& debut_increment,int& in }; }; liste_posi_BI.push_back(pos_ent); -// // on ré-ordonne la liste, qui normalement ne doit avoir que des singletons -// liste_posi_BI.sort(); // normalement ne sert à rien }; // on met à jour la variable dernier_increment_lu - dernier_increment_lu = inc_lu; - // retour - return true; + dernier_increment_lu = inc_lu; + // retour + retour = true; }; - + + // retour unique + return retour; }; // enregistrement de la position // normalement correspond à un début d'incrément void UtilLecture::Enregistrement_position_increment_base_info(int incr) - { // récup de la position + { + // récup de la position + #ifndef UTILISATION_MPI streampos position_inter=0; position_inter = sort_BI->tellp(); + #else + MPI_Offset position_inter=0; + MPI_File_get_position(*sort_MPI_BI, &position_inter); + #endif // on enregistre la position dans la liste de position // on regarde si l'incrément demandé n'a pas déjà été enregistré Position_BI pos_ent(position_inter,incr); diff --git a/Maillage/DdlLim.cc b/Maillage/DdlLim.cc index 649ca86..848960b 100644 --- a/Maillage/DdlLim.cc +++ b/Maillage/DdlLim.cc @@ -741,7 +741,7 @@ ostream & operator << ( ostream & sort,const DdlLim & dlim) }; // affichage et definition interactive des commandes -void DdlLim::Info_commande_DdlLim(ofstream & sort,bool plusieurs_maillages) +void DdlLim::Info_commande_DdlLim(ostream & sort,bool plusieurs_maillages) { //On va proposer un menu string rep=" "; string nom_courbe="_"; diff --git a/Maillage/DdlLim.h b/Maillage/DdlLim.h index b2ab92e..f0c3d8b 100644 --- a/Maillage/DdlLim.h +++ b/Maillage/DdlLim.h @@ -217,7 +217,7 @@ class DdlLim // affichage et definition interactive des commandes // plusieurs_maillages : indique si oui ou non, il y a plusieurs maillage - void Info_commande_DdlLim(ofstream & sort,bool plusieurs_maillages); + void Info_commande_DdlLim(ostream & sort,bool plusieurs_maillages); // Validation on non de l'activité du ddlLim void Validation(const double& temps) {precedent = Temps_actif(temps);}; diff --git a/Maillage/DiversStockage.cc b/Maillage/DiversStockage.cc index 18478e1..a970218 100644 --- a/Maillage/DiversStockage.cc +++ b/Maillage/DiversStockage.cc @@ -999,7 +999,7 @@ void DiversStockage::Info_commande_DiversStockage2(UtilLecture & entreePrinc) // lecture base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void DiversStockage::Lecture_base_info(ifstream& entr,const int cas) +void DiversStockage::Lecture_base_info(istream& entr,const int cas) { // a priori les données stockées ne sont pas variables d'où seule le cas = 1 // est utilisé if (cas == 1 ) @@ -1113,7 +1113,7 @@ void DiversStockage::Lecture_base_info(ifstream& entr,const int cas) // écriture base info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void DiversStockage::Ecriture_base_info(ofstream& sort,const int cas) +void DiversStockage::Ecriture_base_info(ostream& sort,const int cas) { // a priori les données stockées ne sont pas variables d'où seule le cas = 1 // est utilisé if (cas == 1 ) diff --git a/Maillage/DiversStockage.h b/Maillage/DiversStockage.h index e6bad54..8300ed8 100644 --- a/Maillage/DiversStockage.h +++ b/Maillage/DiversStockage.h @@ -155,11 +155,11 @@ class DiversStockage // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); private : // VARIABLES PROTEGEES : diff --git a/Maillage/I_O_Condilineaire.cc b/Maillage/I_O_Condilineaire.cc index ae62c0d..8289a23 100644 --- a/Maillage/I_O_Condilineaire.cc +++ b/Maillage/I_O_Condilineaire.cc @@ -714,7 +714,7 @@ void I_O_Condilineaire::Lecture(UtilLecture & entreePrinc) }; // affichage des commandes particulières à la définition d'une condition linéaire -void I_O_Condilineaire::Info_commande_conditionLineaire(ofstream & sort,bool plusieurs_maillages) +void I_O_Condilineaire::Info_commande_conditionLineaire(ostream & sort,bool plusieurs_maillages) { //On va proposer un menu pour choisir entre différents types de conditions linéaires int type_CLL=0; // =0 non défini, =1 -> projection sur un plan ou une droite diff --git a/Maillage/I_O_Condilineaire.h b/Maillage/I_O_Condilineaire.h index adfcbc5..37ebec4 100644 --- a/Maillage/I_O_Condilineaire.h +++ b/Maillage/I_O_Condilineaire.h @@ -178,7 +178,7 @@ class I_O_Condilineaire : public Condilineaire Condilineaire& ConstructionCondition(Tableau & t_noe,Condilineaire& condi_actuelle); // affichage des commandes particulières à la définition d'une condition linéaire - void Info_commande_conditionLineaire(ofstream & sort,bool plusieurs_maillages); + void Info_commande_conditionLineaire(ostream & sort,bool plusieurs_maillages); // récupération de l'énuméré du type de ddl considéré par la condition limite linéaire Enum_ddl TypeEnu() const {return enu;}; diff --git a/Maillage/LesCondLim.cc b/Maillage/LesCondLim.cc index d52fb97..e765502 100644 --- a/Maillage/LesCondLim.cc +++ b/Maillage/LesCondLim.cc @@ -2639,7 +2639,7 @@ void LesCondLim::ReacApresCHrepere(Vecteur& residu,LesMaillages * lesMail, // affichage sur la sortie sort des reactions -void LesCondLim::Affiche_reaction(ofstream& sort,const LesMaillages * lesMail) const +void LesCondLim::Affiche_reaction(ostream& sort,const LesMaillages * lesMail) const { #ifdef UTILISATION_MPI // cas d'un calcul //, seule le CPU 0 est concerné @@ -2951,7 +2951,7 @@ bool LesCondLim::CoLinUneOpe_ext(Mat_abstraite & matglob,Vecteur& vecglob // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesCondLim::Lecture_base_info(ifstream& ent,const int cas,LesReferences& ,LesCourbes1D& +void LesCondLim::Lecture_base_info(istream& ent,const int cas,LesReferences& ,LesCourbes1D& ,LesFonctions_nD& lesFonctionsnD) { // les conditions linéaires qui varies par exemples dues au contact sont stockées // autre part, dans LesContacts par exemple @@ -2999,7 +2999,7 @@ void LesCondLim::Lecture_base_info(ifstream& ent,const int cas,LesReferences& ,L // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesCondLim::Ecriture_base_info(ofstream& sort,const int cas) +void LesCondLim::Ecriture_base_info(ostream& sort,const int cas) { // les conditions linéaires qui varies par exemples dues au contact sont stockées // autre part, dans LesContacts par exemple switch (cas) diff --git a/Maillage/LesCondLim.h b/Maillage/LesCondLim.h index da4a298..6fd2f44 100644 --- a/Maillage/LesCondLim.h +++ b/Maillage/LesCondLim.h @@ -285,7 +285,7 @@ class LesCondLim LesReferences* lesRef,const Nb_assemb& nb_casAssemb,int cas); // affichage sur la sortie sort des reactions - void Affiche_reaction(ofstream& sort,const LesMaillages * lesMail) const ; + void Affiche_reaction(ostream& sort,const LesMaillages * lesMail) const ; // ------------------ conditions linéaires externes ---------------------------------------------- @@ -389,12 +389,12 @@ class LesCondLim // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); //------- temps cpu ----- // retourne temps cumulé pour imposer les CL imposées diff --git a/Maillage/LesMaillages.cc b/Maillage/LesMaillages.cc index a5a2999..9516908 100644 --- a/Maillage/LesMaillages.cc +++ b/Maillage/LesMaillages.cc @@ -58,6 +58,8 @@ LesMaillages::LesMaillages(): ,pour_statistique_t_de_ddl() #ifdef UTILISATION_MPI ,temps_transfert_long(),v_integ(),temps_serialisation() + // pour les i/o + ,buffer_io_MPI() #endif { cout << "\n erreur: ce constructeur ne doit pas etre utilise !!" @@ -81,6 +83,8 @@ LesMaillages::LesMaillages(UtilLecture * ent,ParaGlob * para,LesReferences* Ref) ,pour_statistique_t_de_ddl() #ifdef UTILISATION_MPI ,temps_transfert_long(),v_integ(),temps_serialisation() + // pour les i/o + ,buffer_io_MPI() #endif { lesRef = Ref; // mise à jour de la map qui fait la liaison nom de maillage <=> numéro de maillage @@ -106,8 +110,19 @@ LesMaillages::~LesMaillages() { int tabMaillage_Taille=tabMaillage.Taille(); if (tabMaillage_Taille>=1) for (int i=1;i<= tabMaillage_Taille;i++) - if (tabMaillage(i)!=NULL) + {if (tabMaillage(i)!=NULL) {delete tabMaillage(i);tabMaillage(i)=NULL;} + #ifdef UTILISATION_MPI + // pour les i/o retardées + int taille_mail = buffer_io_MPI(i).Taille(); + Tableau < char * > & buffer_io_MPI_i = buffer_io_MPI(i); // pour simplifier + for (int j=1;j<=taille_mail;j++) + if (buffer_io_MPI_i(j) != NULL) + {delete buffer_io_MPI_i(j); + buffer_io_MPI_i(j) = NULL; + }; + #endif + }; }; // METHODES PUBLIQUES : @@ -364,6 +379,27 @@ void LesMaillages::LectureLesMaillages() }; // on s'occupe de mettre à jour les types de pb et les ddl types associés Mise_a_jour_type_pb_type_associe_ddl(); + +#ifdef UTILISATION_MPI + // pour les i/o retardées on va dimensionner les buffer + buffer_io_MPI.Change_taille(nbMaillageTotal); + for (int i=1;i<=nbMaillageTotal;i++) + { + + } + + + + +// int taille_mail = buffer_io_MPI(i).Taille(); +// Tableau < char * > & buffer_io_MPI_i = buffer_io_MPI(i); // pour simplifier +// for (int j=1;j<=taille_mail;j++) +// if (buffer_io_MPI_i(j) != NULL) +// {delete buffer_io_MPI_i(j); +// buffer_io_MPI_i(j) = NULL; +// }; +#endif + if (ParaGlob::NiveauImpression() >= 4) cout << " fin de la lecture des maillages " << endl; diff --git a/Maillage/LesMaillages.h b/Maillage/LesMaillages.h index fdb1fb9..0ea6e8d 100644 --- a/Maillage/LesMaillages.h +++ b/Maillage/LesMaillages.h @@ -808,13 +808,13 @@ class LesMaillages // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_LesMaillages(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_LesMaillages(ostream& sort,const Enum_IO_XML enu) const ; // ------ informations utiles par exemples pour la visualisation @@ -927,6 +927,8 @@ class LesMaillages Temps_CPU_HZpp temps_transfert_long ; Temps_CPU_HZpp temps_serialisation ; Vecteur v_integ; // conteneur intermédiaire de transfert + // pour les i/o + Tableau > buffer_io_MPI; #endif //pour_statistique_de_ddl a la même dimension que ref_statistique diff --git a/Maillage/LesMaillages2.cc b/Maillage/LesMaillages2.cc index 12947e7..a7e690c 100644 --- a/Maillage/LesMaillages2.cc +++ b/Maillage/LesMaillages2.cc @@ -246,7 +246,7 @@ void LesMaillages::Libere_Ddl_representatifs_des_physiques(Enum_boolddl enubold) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesMaillages::Lecture_base_info(ifstream& ent,const int cas) +void LesMaillages::Lecture_base_info(istream& ent,const int cas) { string toto; // cout << "\n debug **** LesMaillages::Lecture_base_info\n" // << "\n entr.rdstate() " << ent.rdstate() << flush; @@ -766,7 +766,7 @@ void LesMaillages::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesMaillages::Ecriture_base_info(ofstream& sort,const int cas) +void LesMaillages::Ecriture_base_info(ostream& sort,const int cas) { sort << "\n ****les_maillages:_nombre= " << nbMaillageTotal ; for (int i1 = 1; i1<= nbMaillageTotal; i1++) tabMaillage(i1)->Ecriture_base_info(sort,cas); @@ -816,7 +816,7 @@ void LesMaillages::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void LesMaillages::SchemaXML_LesMaillages(ofstream& sort,const Enum_IO_XML enu) const +void LesMaillages::SchemaXML_LesMaillages(ostream& sort,const Enum_IO_XML enu) const { switch (enu) {case XML_TYPE_GLOBAUX: { // cas des classes de base diff --git a/Maillage/Maillage.cc b/Maillage/Maillage.cc index d397eb3..4754144 100755 --- a/Maillage/Maillage.cc +++ b/Maillage/Maillage.cc @@ -39,6 +39,12 @@ using namespace std; //introduces namespace std #include #include "List_io.h" #include "CharUtil.h" + +// au cas où pour la bufferisation des io +#include // std::string +#include // std::cout +#include // std::stringstream + //#ifndef SYSTEM_MAC_OS_X_unix // #include "Frontier.h" //#endif @@ -63,6 +69,10 @@ Maillage::Maillage (map < string, int , std::less > & lisNomMail,int nm ,ddl_representatifs_des_physiques(),types_de_problemes() , ind_elem(),tab_sens_element() // tableaux internes utilisés par Orientation_elements_mitoyens_recursif ,detruire_les_noeuds_et_elements(true) +#ifdef UTILISATION_MPI + ,buffer_io_MPI() //,tablcarI_O_gros(NULL),taille_tablcarI_O_gros(10000) + ,tailles_buffer() +#endif { if (nom_maill == ".") {// tout d'abord on donne un nom par défaut au maillage @@ -77,6 +87,11 @@ Maillage::Maillage (map < string, int , std::less > & lisNomMail,int nm }; // maintenant on associe le nom au numéro dans la map listeNomMail[nomDuMaillage]=idmail; +// #ifdef UTILISATION_MPI +// tablcarI_O_gros = new char [taille_tablcarI_O_gros] ; // def du tableau de travail +// #endif + + }; // Constructeur fonction d'une dimension, du nombre de noeuds @@ -90,6 +105,9 @@ Maillage::Maillage (map < string, int , std::less > & lisNomMail ,ddl_representatifs_des_physiques(),types_de_problemes() , ind_elem(),tab_sens_element() // tableaux internes utilisés par Orientation_elements_mitoyens_recursif ,detruire_les_noeuds_et_elements(true) +#ifdef UTILISATION_MPI + ,buffer_io_MPI(),tailles_buffer() +#endif {if (nmail <=0) { cout << "\nErreur : numero de maillage invalide !\n"; @@ -143,6 +161,9 @@ Maillage::Maillage (map < string, int , std::less > & lisNomMail ,ddl_representatifs_des_physiques(),types_de_problemes() , ind_elem(),tab_sens_element() // tableaux internes utilisés par Orientation_elements_mitoyens_recursif ,detruire_les_noeuds_et_elements(true) +#ifdef UTILISATION_MPI + ,buffer_io_MPI(),tailles_buffer() +#endif { if (ParaGlob::NiveauImpression() >= 5) cout << " \n creation du maillage: " << nom_maill << endl; @@ -279,6 +300,9 @@ Maillage::Maillage (const Maillage& mail): ,types_de_problemes(mail.types_de_problemes) , ind_elem(),tab_sens_element() // tableaux internes utilisés par Orientation_elements_mitoyens_recursif ,detruire_les_noeuds_et_elements(true) +#ifdef UTILISATION_MPI + ,buffer_io_MPI(),tailles_buffer() +#endif { // tout d'abord on donne un nom par défaut au maillage nomDuMaillage = "pas_de_nom"; @@ -305,6 +329,10 @@ Maillage::Maillage (map < string, int , std::less > & lisNomMail ,types_de_problemes(mail.types_de_problemes) , ind_elem(),tab_sens_element() // tableaux internes utilisés par Orientation_elements_mitoyens_recursif ,detruire_les_noeuds_et_elements(true) +#ifdef UTILISATION_MPI + ,buffer_io_MPI(),tailles_buffer() +#endif + { // on vérifie que le nom de maillage fourni n'existe pas if (listeNomMail.find(nomDuMaillage) != listeNomMail.end()) { cout << "\n erreur, le nom de maillage demande existe deja : " << nomDuMaillage @@ -354,7 +382,8 @@ Maillage::~Maillage() { for (int i=1;i<= tab_noeud.Taille();i++) delete tab_noeud(i); for (int i=1;i<= tab_element.Taille();i++) - delete tab_element(i); + {delete tab_element(i); + }; }; // pas de destruction de tab_noeud_front car ce sont des noeuds de tab_noeud, ils sont déjà détruit }; @@ -563,6 +592,7 @@ Maillage::LectureMaillage(UtilLecture * entreePrinc,LesReferences& lesRef) if (ParaGlob::NiveauImpression() >= 5) cout << " fin lecture de maillage " << endl; // ----- on s'occupe maintenant de définir les types de pb gérés ------ Mise_a_jour_type_pb_type_associe_ddl(); + }; // lecture et application des opérations d'affinages sur le maillage: ex:déplacement solide @@ -2346,7 +2376,7 @@ double Maillage::Min_dist2Noeud_des_elements(Enum_dure temps) const // lecture base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Maillage::Lecture_base_info(ifstream& entr,const int cas) +void Maillage::Lecture_base_info(istream& entr, int cas) {switch (cas) { case 1 : // ------- on récupère tout ------------------------- {// l'id et le nom du maillage et la dimension @@ -2395,7 +2425,7 @@ void Maillage::Lecture_base_info(ifstream& entr,const int cas) if (dime != dimension) cout << "\nErreur : valeur de la dimension non coherente avec " << " l'espace de travail!\n" - << "Maillage::Lecture_base_info(ofstream& sort,int cas)" + << "Maillage::Lecture_base_info(istream& sort,int cas)" << endl; cout << " === lecture du maillage " << nomDuMaillage << " nb " << idmail << "\n" ; //------------- lecture des noeuds ------------- @@ -2439,7 +2469,7 @@ void Maillage::Lecture_base_info(ifstream& entr,const int cas) << " est different de celui stocke sur le .BI: " << inter << "\n cas d'un calcul parallele avec lecture initiale du .BI, cpu nb:" << ParaGlob::Monde()->rank() << " !! " - << "\n Maillage::Lecture_base_info(ofstream& sort,int cas)" + << "\n Maillage::Lecture_base_info(istream& sort,int cas)" << endl; Sortie (1); }; @@ -2527,7 +2557,7 @@ void Maillage::Lecture_base_info(ifstream& entr,const int cas) if (nomDuMail != nomDuMaillage) { cout << "\nErreur : le nom du maillage lu (" << nomDuMail << ") n'est pas identique avec celui en cours (" << nomDuMaillage << ") !! " - << "\n Maillage::Lecture_base_info(ofstream& sort,int cas)" + << "\n Maillage::Lecture_base_info(istream& sort,int cas)" << endl; Sortie (1); }; @@ -2557,7 +2587,7 @@ void Maillage::Lecture_base_info(ifstream& entr,const int cas) << " est different de celui stocke sur le .BI: " << inter << "\n cas d'un calcul parallele avec lecture courante du .BI, cpu nb:" << ParaGlob::Monde()->rank() << " !! " - << "\n Maillage::Lecture_base_info(ofstream& sort,int cas)" + << "\n Maillage::Lecture_base_info(istream& sort,int cas)" << endl; Sortie (1); }; @@ -2581,7 +2611,7 @@ void Maillage::Lecture_base_info(ifstream& entr,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "Maillage::Lecture_base_info(ofstream& sort,int cas)" + cout << "Maillage::Lecture_base_info(istream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); }; @@ -2591,23 +2621,42 @@ void Maillage::Lecture_base_info(ifstream& entr,const int cas) // écriture base info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Maillage::Ecriture_base_info(ofstream& sort,const int cas) -{switch (cas) +void Maillage::Ecriture_base_info(ostream& sort, int cas) +{ +#ifdef UTILISATION_MPI + int proc_en_cours = ParaGlob::Monde()->rank(); + // 1) dans le cas d'un proc 0 ou i, on redéfinit le flux de sortie, pour bufferiser les infos en sortie + // qui sont ensuite sortie via MPI i-o à l'aide de la méthode Ecriture_base_info_MPI_IO + // les récupérations et les sorties sont effectuées de manière asynchrone par rapport aux autres proc + // 2) seul le proc 0 sort l'entête et les noeuds + // 3) seules les proc i sortent les éléments +#endif + + switch (cas) { case 1 : // ------- on sauvegarde tout ------------------------- - {// l'id et le nom du maillage et la dimension - sort << "\n num= " << idmail <<" "<< nomDuMaillage <<" " - << "dim= " << dimension; + { + #ifdef UTILISATION_MPI + + if (proc_en_cours == 0) // première partie dédié proc 0 + {// dimensionnement de buffer_io_MPI + int taille_buffer_io_MPI = 1; // la partie 1 + noeuds + buffer_io_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + std::ostringstream sort; // redéfinition de sort + #endif + // l'id et le nom du maillage et la dimension + sort << "\n num= " << idmail <<" "<< nomDuMaillage <<" " + << "dim= " << dimension; // les types de problèmes associés // {list ::iterator il,ilfin=types_de_problemes.end(); // sort <<"\n types_de_problemes: " << types_de_problemes.size() ; // for (il=types_de_problemes.begin();il != ilfin;il++) // sort << NomElemTypeProblem(*il); // }; - {int tail = types_de_problemes.Taille(); - sort <<"\n types_de_problemes: " << tail ; - for (int i=1;i<=tail;i++) - sort << " "<< NomElemTypeProblem(types_de_problemes(i)); - }; + {int tail = types_de_problemes.Taille(); + sort <<"\n types_de_problemes: " << tail ; + for (int i=1;i<=tail;i++) + sort << " "<< NomElemTypeProblem(types_de_problemes(i)); + }; // les ddl associés // {list ::iterator il,ilfin=ddl_representatifs_des_physiques.end(); @@ -2615,108 +2664,356 @@ void Maillage::Ecriture_base_info(ofstream& sort,const int cas) // for (il=ddl_representatifs_des_physiques.begin();il != ilfin;il++) // Nom_ddl(*il); // }; - {int tail = ddl_representatifs_des_physiques.Taille(); - sort <<"\n type_de_ddl_associes: " << tail; - for (int i=1;i<=tail;i++) - sort << " "<< Nom_ddl(ddl_representatifs_des_physiques(i)); - }; + {int tail = ddl_representatifs_des_physiques.Taille(); + sort <<"\n type_de_ddl_associes: " << tail; + for (int i=1;i<=tail;i++) + sort << " "<< Nom_ddl(ddl_representatifs_des_physiques(i)); + }; + + sort <<"\n"; + //------------- les noeuds ------------- + // le nombre de noeud + int nbNoeud = tab_noeud.Taille(); + sort << nbNoeud << " noeuds \n"; + // sorti des noeuds + for (int i=1; i<=nbNoeud;i++) + tab_noeud(i)->Ecriture_base_info(sort,cas); + // ------------ les elements finis ----------- + sort << "\n --les_elements-- "; + // le nombre d'élément total + int nbElement = tab_element.Taille(); + sort <<"\n nombre_total_element " << nbElement ; + #ifdef UTILISATION_MPI + sort << "\n "; + buffer_io_MPI(1) = sort.str(); // on sauvegarde + } + #endif + - sort <<"\n"; - //------------- les noeuds ------------- - // le nombre de noeud - int nbNoeud = tab_noeud.Taille(); - sort << nbNoeud << " noeuds \n"; - // sorti des noeuds - for (int i=1; i<=nbNoeud;i++) - tab_noeud(i)->Ecriture_base_info(sort,cas); - // ------------ les elements finis ----------- - sort << "\n --les_elements-- "; - // le nombre d'élément total - int nbElement = tab_element.Taille(); - sort <<"\n nombre_total_element " << nbElement ; // écriture des éléments - #ifndef UTILISATION_MPI + #ifndef UTILISATION_MPI // cas d'un calcul uni-CPU for (int j=1;j<=nbElement;j++) - #else - // cas d'un calcul // - // on récupère la distribution d'éléments concernant le cpu en cours - const list list_elem_cpu = ParaGlob::param->const_List_element_CPU_en_cours(idmail); - // le nombre d'élément spécifiquement pour le CPU - int nbElement_cpu = list_elem_cpu.size(); - sort <<"\n nombre_element_CPU " << nbElement_cpu ; - // écriture des éléments - // on balaie les éléments nécessaires - list ::const_iterator il,ilfin=list_elem_cpu.end(); - for (il = list_elem_cpu.begin();il != ilfin;il++) - {int j = (*il); + #else + if (proc_en_cours != 0) // seules les proc i gèrent les éléments + {// on récupère la distribution d'éléments concernant le cpu en cours + const list list_elem_cpu = ParaGlob::param->const_List_element_CPU_en_cours(idmail); + // le nombre d'élément spécifiquement pour le CPU + int nbElement_cpu = list_elem_cpu.size(); + // dimensionnement de buffer_io_MPI + int taille_buffer_io_MPI = nbElement_cpu + 2; // entête + 1 buffer par élément + un saut de ligne + buffer_io_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + {std::stringstream sort; // redéfinition de sort + sort <<"\n nombre_element_CPU " << nbElement_cpu ; + } + // écriture des éléments + // on balaie les éléments nécessaires + list ::const_iterator il,ilfin=list_elem_cpu.end(); + int indice_buffer_io_MPI=2; + for (il = list_elem_cpu.begin();il != ilfin;il++,indice_buffer_io_MPI++) + {int j = (*il); + std::stringstream sort; // redéfinition de sort #endif - { // tout d'abord les données de différentiation - // numéro geometrie et interpolation - sort << "\n\n element: " << tab_element(j)->Num_elt() << " " - << tab_element(j)->Id_geometrie() << " " - << tab_element(j)->Interpolation() << " " - << tab_element(j)->TypeProblem() << " " - << tab_element(j)->Infos_annexe() << "\n"; - // puis les données de l'élément - tab_element(j)->Ecriture_base_info(sort,cas); - }; + { // tout d'abord les données de différentiation + // numéro geometrie et interpolation + sort << "\n\n element: " << tab_element(j)->Num_elt() << " " + << tab_element(j)->Id_geometrie() << " " + << tab_element(j)->Interpolation() << " " + << tab_element(j)->TypeProblem() << " " + << tab_element(j)->Infos_annexe() << "\n"; + // puis les données de l'élément + tab_element(j)->Ecriture_base_info(sort,cas); + }; #ifdef UTILISATION_MPI - // fin cas d'un calcul // - }; - #endif - sort << "\n "; + buffer_io_MPI(indice_buffer_io_MPI) = sort.str(); // on sauvegarde + }; + // sortie du retour à la ligne + std::stringstream sort; // redéfinition de sort + sort << "\n "; + buffer_io_MPI(taille_buffer_io_MPI) = sort.str(); // on sauvegarde + }; + #endif + + #ifndef UTILISATION_MPI + sort << "\n "; + #endif // ------------ les elements frontières ----------- // ne sont pas sauvegardé car reconstruit à la demande break; - } + } case 2 : // ----------- sauvegarde uniquement de se qui varie -------------------- - {// le nom du maillage pour vérification en lecture - sort << "\nnomDuMail= " << nomDuMaillage << "\n"; - //------------- les noeuds ------------- - int nbNoeud = tab_noeud.Taille(); - // sorti des noeuds - for (int i=1; i<=nbNoeud;i++) - tab_noeud(i)->Ecriture_base_info(sort,cas); + { + #ifdef UTILISATION_MPI + if (proc_en_cours == 0) // première partie dédié proc 0 + {// dimensionnement de buffer_io_MPI + int taille_buffer_io_MPI = 1; // la partie 1 + noeuds + buffer_io_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + std::ostringstream sort; // redéfinition de sort + #endif + // le nom du maillage pour vérification en lecture + sort << "\nnomDuMail= " << nomDuMaillage << "\n"; + //------------- les noeuds ------------- + int nbNoeud = tab_noeud.Taille(); + // sorti des noeuds + for (int i=1; i<=nbNoeud;i++) + tab_noeud(i)->Ecriture_base_info(sort,cas); + + #ifdef UTILISATION_MPI + sort << "\n "; + buffer_io_MPI(1) = sort.str(); // on sauvegarde + }; + #endif + // ------------ les elements finis ----------- int nbElement = tab_element.Taille(); - #ifndef UTILISATION_MPI - // cas d'un calcul uni-CPU + #ifndef UTILISATION_MPI + // cas d'un calcul uni-CPU for (int j=1;j<=nbElement;j++) - #else - // cas d'un calcul // - // on récupère la distribution d'éléments concernant le cpu en cours - const list list_elem_cpu = ParaGlob::param->const_List_element_CPU_en_cours(idmail); - // le nombre d'élément spécifiquement pour le CPU - int nbElement_cpu = list_elem_cpu.size(); - sort <<"\n nombre_element_CPU " << nbElement_cpu ; - // écriture des éléments - // on balaie les éléments nécessaires - list ::const_iterator il,ilfin=list_elem_cpu.end(); - for (il = list_elem_cpu.begin();il != ilfin;il++) - {int j = (*il); - #endif - {sort << "\n\n element_nb: " << tab_element(j)->Num_elt() << " "; - tab_element(j)->Ecriture_base_info(sort,cas); + #else + if (proc_en_cours != 0) // seules les proc i gèrent les éléments + {// on récupère la distribution d'éléments concernant le cpu en cours + const list list_elem_cpu = ParaGlob::param->const_List_element_CPU_en_cours(idmail); + // le nombre d'élément spécifiquement pour le CPU + int nbElement_cpu = list_elem_cpu.size(); + // dimensionnement de buffer_io_MPI + int taille_buffer_io_MPI = nbElement_cpu + 2; // entête + 1 buffer par élément + un saut de ligne + buffer_io_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + {std::stringstream sort; // redéfinition de sort + sort <<"\n nombre_element_CPU " << nbElement_cpu ; + } + // écriture des éléments + // on balaie les éléments nécessaires + list ::const_iterator il,ilfin=list_elem_cpu.end(); + int indice_buffer_io_MPI=2; + for (il = list_elem_cpu.begin();il != ilfin;il++,indice_buffer_io_MPI++) + {int j = (*il); + std::stringstream sort; // redéfinition de sort + #endif + {sort << "\n\n element_nb: " << tab_element(j)->Num_elt() << " "; + tab_element(j)->Ecriture_base_info(sort,cas); + }; + #ifdef UTILISATION_MPI + buffer_io_MPI(indice_buffer_io_MPI) = sort.str(); // on sauvegarde + }; + // sortie du retour à la ligne + std::stringstream sort; // redéfinition de sort + sort << "\n "; + buffer_io_MPI(taille_buffer_io_MPI) = sort.str(); // on sauvegarde }; - #ifdef UTILISATION_MPI - // fin cas d'un calcul // - }; - #endif + #endif - // ------------ les elements frontières ----------- - // ne sont pas sauvegardé car reconstruit à la demande + #ifndef UTILISATION_MPI + sort << "\n "; + #endif + // ------------ les elements frontières ----------- + // ne sont pas sauvegardé car reconstruit à la demande break; - } + } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "Maillage::Ecriture_base_info(ofstream& sort,int cas)" + cout << "Maillage::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); }; }; }; + +#ifdef UTILISATION_MPI +// écriture MPI des infos bufferisées +void Maillage::Ecriture_base_info_MPI_IO(ostream& sort,const int cas) + { + int proc_en_cours = ParaGlob::Monde()->rank(); + Tableau tab_offset; // le tableau d'offset + if (proc_en_cours == 0) + { + + } + + + + + + + // 1) dans le cas d'un proc 0 ou i, on redéfinit le flux de sortie, pour bufferiser les infos en sortie + // qui sont ensuite sortie via MPI i-o à l'aide de la méthode Ecriture_base_info_MPI_IO + // les récupérations et les sorties sont effectuées de manière asynchrone par rapport aux autres proc + // 2) seul le proc 0 sort l'entête et les noeuds + // 3) seules les proc i sortent les éléments + + switch (cas) + { case 1 : // ------- on sauvegarde tout ------------------------- + { + if (proc_en_cours == 0) // première partie dédié proc 0 + {// dimensionnement de buffer_io_MPI + int taille_buffer_io_MPI = 1; // la partie 1 + noeuds + buffer_io_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + std::ostringstream sort; // redéfinition de sort + // l'id et le nom du maillage et la dimension + sort << "\n num= " << idmail <<" "<< nomDuMaillage <<" " + << "dim= " << dimension; + // les types de problèmes associés + // {list ::iterator il,ilfin=types_de_problemes.end(); + // sort <<"\n types_de_problemes: " << types_de_problemes.size() ; + // for (il=types_de_problemes.begin();il != ilfin;il++) + // sort << NomElemTypeProblem(*il); + // }; + {int tail = types_de_problemes.Taille(); + sort <<"\n types_de_problemes: " << tail ; + for (int i=1;i<=tail;i++) + sort << " "<< NomElemTypeProblem(types_de_problemes(i)); + }; + + // les ddl associés + // {list ::iterator il,ilfin=ddl_representatifs_des_physiques.end(); + // sort <<"\n type_de_ddl_associes: " << ddl_representatifs_des_physiques.size(); + // for (il=ddl_representatifs_des_physiques.begin();il != ilfin;il++) + // Nom_ddl(*il); + // }; + {int tail = ddl_representatifs_des_physiques.Taille(); + sort <<"\n type_de_ddl_associes: " << tail; + for (int i=1;i<=tail;i++) + sort << " "<< Nom_ddl(ddl_representatifs_des_physiques(i)); + }; + + sort <<"\n"; + //------------- les noeuds ------------- + // le nombre de noeud + int nbNoeud = tab_noeud.Taille(); + sort << nbNoeud << " noeuds \n"; + // sorti des noeuds + for (int i=1; i<=nbNoeud;i++) + tab_noeud(i)->Ecriture_base_info(sort,cas); + // ------------ les elements finis ----------- + sort << "\n --les_elements-- "; + // le nombre d'élément total + int nbElement = tab_element.Taille(); + sort <<"\n nombre_total_element " << nbElement ; + sort << "\n "; + buffer_io_MPI(1) = sort.str(); // on sauvegarde + } + + + // écriture des éléments + if (proc_en_cours != 0) // seules les proc i gèrent les éléments + {// on récupère la distribution d'éléments concernant le cpu en cours + const list list_elem_cpu = ParaGlob::param->const_List_element_CPU_en_cours(idmail); + // le nombre d'élément spécifiquement pour le CPU + int nbElement_cpu = list_elem_cpu.size(); + // dimensionnement de buffer_io_MPI + int taille_buffer_io_MPI = nbElement_cpu + 2; // entête + 1 buffer par élément + un saut de ligne + buffer_io_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + {std::stringstream sort; // redéfinition de sort + sort <<"\n nombre_element_CPU " << nbElement_cpu ; + } + // écriture des éléments + // on balaie les éléments nécessaires + list ::const_iterator il,ilfin=list_elem_cpu.end(); + int indice_buffer_io_MPI=2; + for (il = list_elem_cpu.begin();il != ilfin;il++,indice_buffer_io_MPI++) + {int j = (*il); + std::stringstream sort; // redéfinition de sort + { // tout d'abord les données de différentiation + // numéro geometrie et interpolation + sort << "\n\n element: " << tab_element(j)->Num_elt() << " " + << tab_element(j)->Id_geometrie() << " " + << tab_element(j)->Interpolation() << " " + << tab_element(j)->TypeProblem() << " " + << tab_element(j)->Infos_annexe() << "\n"; + // puis les données de l'élément + tab_element(j)->Ecriture_base_info(sort,cas); + }; + buffer_io_MPI(indice_buffer_io_MPI) = sort.str(); // on sauvegarde + }; + // sortie du retour à la ligne + std::stringstream sort; // redéfinition de sort + sort << "\n "; + buffer_io_MPI(taille_buffer_io_MPI) = sort.str(); // on sauvegarde + }; + sort << "\n "; + // ------------ les elements frontières ----------- + // ne sont pas sauvegardé car reconstruit à la demande + break; + } + case 2 : // ----------- sauvegarde uniquement de se qui varie -------------------- + { + #ifdef UTILISATION_MPI + if (proc_en_cours == 0) // première partie dédié proc 0 + {// dimensionnement de buffer_io_MPI + int taille_buffer_io_MPI = 1; // la partie 1 + noeuds + buffer_io_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + std::ostringstream sort; // redéfinition de sort + #endif + // le nom du maillage pour vérification en lecture + sort << "\nnomDuMail= " << nomDuMaillage << "\n"; + //------------- les noeuds ------------- + int nbNoeud = tab_noeud.Taille(); + // sorti des noeuds + for (int i=1; i<=nbNoeud;i++) + tab_noeud(i)->Ecriture_base_info(sort,cas); + + #ifdef UTILISATION_MPI + sort << "\n "; + buffer_io_MPI(1) = sort.str(); // on sauvegarde + }; + #endif + + // ------------ les elements finis ----------- + int nbElement = tab_element.Taille(); + #ifndef UTILISATION_MPI + // cas d'un calcul uni-CPU + for (int j=1;j<=nbElement;j++) + #else + if (proc_en_cours != 0) // seules les proc i gèrent les éléments + {// on récupère la distribution d'éléments concernant le cpu en cours + const list list_elem_cpu = ParaGlob::param->const_List_element_CPU_en_cours(idmail); + // le nombre d'élément spécifiquement pour le CPU + int nbElement_cpu = list_elem_cpu.size(); + // dimensionnement de buffer_io_MPI + int taille_buffer_io_MPI = nbElement_cpu + 2; // entête + 1 buffer par élément + un saut de ligne + buffer_io_MPI.Change_taille(taille_buffer_io_MPI); // si c'est la bonne taille aucune action + {std::stringstream sort; // redéfinition de sort + sort <<"\n nombre_element_CPU " << nbElement_cpu ; + } + // écriture des éléments + // on balaie les éléments nécessaires + list ::const_iterator il,ilfin=list_elem_cpu.end(); + int indice_buffer_io_MPI=2; + for (il = list_elem_cpu.begin();il != ilfin;il++,indice_buffer_io_MPI++) + {int j = (*il); + std::stringstream sort; // redéfinition de sort + #endif + {sort << "\n\n element_nb: " << tab_element(j)->Num_elt() << " "; + tab_element(j)->Ecriture_base_info(sort,cas); + }; + #ifdef UTILISATION_MPI + buffer_io_MPI(indice_buffer_io_MPI) = sort.str(); // on sauvegarde + }; + // sortie du retour à la ligne + std::stringstream sort; // redéfinition de sort + sort << "\n "; + buffer_io_MPI(taille_buffer_io_MPI) = sort.str(); // on sauvegarde + }; + #endif + + #ifndef UTILISATION_MPI + sort << "\n "; + #endif + // ------------ les elements frontières ----------- + // ne sont pas sauvegardé car reconstruit à la demande + + break; + } + default : + { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; + cout << "Maillage::Ecriture_base_info(ostream& sort,int cas)" + << " cas= " << cas << endl; + Sortie(1); + }; + }; + }; +#endif + // ------ informations utiles par exemples pour la visualisation // retourne les dimensions minis et maxi suivant les axes du repère diff --git a/Maillage/Maillage.h b/Maillage/Maillage.h index 0cff924..e0248a5 100755 --- a/Maillage/Maillage.h +++ b/Maillage/Maillage.h @@ -454,13 +454,19 @@ class Maillage // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); +#ifdef UTILISATION_MPI + // transmission des tailles de buffer: retourne celles concernant le dernier appel de Ecriture_base_info + const Tableau & Tailles_buffer() const {return tailles_buffer;}; + // écriture MPI des infos bufferisées + void Ecriture_base_info_MPI_IO(ostream& sort,const int cas); +#endif // sortie du schemaXML: en fonction de enu - static void SchemaXML_Maillages(ofstream& sort,const Enum_IO_XML enu) ; + static void SchemaXML_Maillages(ostream& sort,const Enum_IO_XML enu) ; // ------ informations utiles par exemples pour la visualisation // retourne les dimensions minis et maxi suivant les axes du repère @@ -609,6 +615,16 @@ class Maillage Tableau ind_elem; // def et init à 0, c-à-d non traité // -- fin variables internes utilisées par Orientation_elements_mitoyens_recursif + + #ifdef UTILISATION_MPI + // pour les i/o retardées + Tableau buffer_io_MPI; // les buffers pour la sortie retardée + Tableau tailles_buffer; // celles concernant le dernier appel de Ecriture_base_info + // tailles_buffer(1) : taille total des infos à sauvegarder +// char* tablcarI_O_gros ; // gros buffer pour I/O brut +// int taille_tablcarI_O_gros; // taille fixe du gros buffer + #endif + // METHODES PROTEGEES : diff --git a/Maillage/Maillage2.cc b/Maillage/Maillage2.cc index 8b55db6..99c0ac3 100644 --- a/Maillage/Maillage2.cc +++ b/Maillage/Maillage2.cc @@ -721,7 +721,7 @@ void Maillage::RelocPtMilieuMailleQuadra() }; // sortie du schemaXML: en fonction de enu -void Maillage::SchemaXML_Maillages(ofstream& sort,const Enum_IO_XML enu) +void Maillage::SchemaXML_Maillages(ostream& sort,const Enum_IO_XML enu) { switch (enu) {case XML_TYPE_GLOBAUX: {// on définit des types pour un maillage diff --git a/Maillage/Noeud.cc b/Maillage/Noeud.cc index 7f09313..10a8e76 100644 --- a/Maillage/Noeud.cc +++ b/Maillage/Noeud.cc @@ -68,7 +68,7 @@ ostream & operator << ( ostream & sort,const Posi_ddl_noeud & a) }; // Affiche les donnees liees au noeud -void Posi_ddl_noeud::Affiche (ofstream& sort) const +void Posi_ddl_noeud::Affiche (ostream& sort) const { // les data sort << " Posi_ddl_noeud " ; sort << nb_maillage << " "<< nb_noeud << " "<< enu << " "; @@ -678,7 +678,7 @@ void Noeud::Info_commande_Noeud(UtilLecture * entreePrinc,Coordonnee& co,int num }; // Affiche les donnees liees au noeud - void Noeud::Affiche (ofstream& sort) const + void Noeud::Affiche (ostream& sort) const { // l'entete sort << " Numero : [ " << num_noeud << " ]****/////, du maillage: < "<< num_Mail @@ -1768,7 +1768,7 @@ void Noeud::LectureDeplacements(UtilLecture *entreePrinc) // cela signifie que le nombre de ddl augmente mais ne diminue pas !!) -void Noeud::Lecture_base_info(ifstream& ent,int cas) +void Noeud::Lecture_base_info(istream& ent,int cas) { // traitement en fonction du cas switch (cas) { case 1 : // ------- on récupère tout ------------------------- @@ -1839,7 +1839,7 @@ void Noeud::Lecture_base_info(ifstream& ent,int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "Noeud::Ecriture_base_info(ofstream& sort,int cas)" + cout << "Noeud::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -1849,7 +1849,7 @@ void Noeud::Lecture_base_info(ifstream& ent,int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Noeud::Ecriture_base_info(ofstream& sort,int cas) +void Noeud::Ecriture_base_info(ostream& sort,int cas) { // traitement en fonction du cas switch (cas) { case 1 : // ------- on sauvegarde tout ------------------------- @@ -1870,7 +1870,7 @@ void Noeud::Ecriture_base_info(ofstream& sort,int cas) } default : { cout << "\nErreur : valeur incorrecte du type d'écriture !\n"; - cout << "Noeud::Ecriture_base_info(ofstream& sort,int cas)" + cout << "Noeud::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); } diff --git a/Maillage/Noeud.h b/Maillage/Noeud.h index 1d6a91f..a5f722f 100644 --- a/Maillage/Noeud.h +++ b/Maillage/Noeud.h @@ -116,7 +116,7 @@ bool operator != ( const Posi_ddl_noeud & a) { if((*this) == a) return false; else return true; }; // Affiche les donnees liees au noeud - void Affiche (ofstream& sort) const; + void Affiche (ostream& sort) const; // récup des données en lecture écriture int& Nb_maillage() {return nb_maillage;}; int& Nb_noeud() {return nb_noeud;}; @@ -207,7 +207,7 @@ class Noeud // le niveau différent de 0 permet d'accèder à plus d'info void Affiche(int niveau=0) const; // Affiche dans sort les donnees liees au noeud - void Affiche(ofstream& sort) const; + void Affiche(ostream& sort) const; inline void Change_num_noeud(int nouveau_num) // Modifie le numero d'identification du noeud @@ -586,7 +586,7 @@ class Noeud // lecture du noeud dans la mémoire void Lecture (UtilLecture *entreePrinc); // sortie du schemaXML: en fonction de enu - static void SchemaXML_Noeud(ofstream& sort,const Enum_IO_XML enu); + static void SchemaXML_Noeud(ostream& sort,const Enum_IO_XML enu); // affichage et definition interactive des commandes // coor: des coordonnees fixée pour un affichage different pour chaque noeud @@ -602,11 +602,11 @@ class Noeud // = 2 : on récupère uniquement les données variables (supposées comme telles) // ( ici on ne redimentionne pas, // cela signifie que le nombre de ddl augmente mais ne diminue pas !!) - void Lecture_base_info(ifstream& ent,int cas); + void Lecture_base_info(istream& ent,int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,int cas); + void Ecriture_base_info(ostream& sort,int cas); // -------- manipulation de types quelconques stockées aux noeuds ------ // les opérations dans les types quelconques ne sont pas faites par le noeud diff --git a/Maillage/Noeud2.cc b/Maillage/Noeud2.cc index 828a39a..b02e01e 100644 --- a/Maillage/Noeud2.cc +++ b/Maillage/Noeud2.cc @@ -1149,7 +1149,7 @@ void Noeud::Suppression_tous_liaisons_noeuds() }; // sortie du schemaXML: en fonction de enu -void Noeud::SchemaXML_Noeud(ofstream& sort,const Enum_IO_XML enu) +void Noeud::SchemaXML_Noeud(ostream& sort,const Enum_IO_XML enu) { switch (enu) {case XML_TYPE_GLOBAUX: {// on définit des types pour un maillage diff --git a/Maillage/VariablesExporter.cc b/Maillage/VariablesExporter.cc index 4506838..4b6d4bd 100755 --- a/Maillage/VariablesExporter.cc +++ b/Maillage/VariablesExporter.cc @@ -1381,6 +1381,9 @@ VariablesExporter::VariablesExporter (): ,list_var_glob_sur_grandeur_globale() ,initiaConteneurQuelconque(false) +#ifdef UTILISATION_MPI + ,buffer_ioBI_MPI(),taille_buffer_ioBI_MPI() +#endif { }; @@ -1414,6 +1417,11 @@ VariablesExporter::VariablesExporter (const VariablesExporter& a): ,list_var_glob_sur_grandeur_globale(a.list_var_glob_sur_grandeur_globale) ,initiaConteneurQuelconque(a.initiaConteneurQuelconque) + +#ifdef UTILISATION_MPI + ,buffer_ioBI_MPI(a.buffer_ioBI_MPI),taille_buffer_ioBI_MPI(a.taille_buffer_ioBI_MPI) +#endif + { }; @@ -2638,7 +2646,7 @@ void VariablesExporter::MiseAjourConstantesUtilisateur(UtilLecture& lec) // lecture base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void VariablesExporter::Lecture_base_info(ifstream& entr,const int cas) +void VariablesExporter::Lecture_base_info(istream& entr,const int cas) {switch (cas) { case 1 : // ------- on récupère tout ------------------------- { @@ -2650,7 +2658,7 @@ void VariablesExporter::Lecture_base_info(ifstream& entr,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type de lecture !\n"; - cout << "VariablesExporter::Lecture_base_info(ofstream& sort,int cas)" + cout << "VariablesExporter::Lecture_base_info(istream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); }; @@ -2660,7 +2668,7 @@ void VariablesExporter::Lecture_base_info(ifstream& entr,const int cas) // écriture base info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void VariablesExporter::Ecriture_base_info(ofstream& sort,const int cas) +void VariablesExporter::Ecriture_base_info(ostream& sort,const int cas) {switch (cas) { case 1 : // ------- on sauvegarde tout ------------------------- { @@ -2728,13 +2736,126 @@ void VariablesExporter::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "VariablesExporter::Ecriture_base_info(ofstream& sort,int cas)" + cout << "VariablesExporter::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); }; }; }; - + + + #ifdef UTILISATION_MPI + // version MPI + void VariablesExporter::Lecture_base_info(MPI_File& ent_MPI,const int cas) + {// on commence par lire la taille du buffer d'offset + // tous les proc lisent + + // 1) ==== la taille de la place de la taille du buffer + int taille_buf = 0; // init + // on encapsule pour ré-utiliser la même trame + { char * buffer_car = new char [16] ; // def du tableau de travail + MPI_Status status; + int ierr = MPI_File_read_all(ent_MPI, buffer_car, 16, MPI_CHAR, &status); + // on crée un flux sur le tableau de caractères: + istrstream * ent_inter = new istrstream(buffer_car,16) ; + // lecture de l'entête + string toto; + (*ent_inter) >> toto; + if (toto != "tout_offset" ) + {cout << "\n **** erreur on devait lire : 'tout_offset' " + << " et on lue "<< toto << " la suite n'est pas possible -> arret !! " + << "\n VariablesExporter::Lecture_base_info(... "<> toto >> taille_buf; + }; + // 2) ==== lecture de la taille du buffer + { char * buffer_car = new char [taille_buf] ; // def du tableau de travail + MPI_Status status; + int ierr = MPI_File_read_all(ent_MPI, buffer_car, taille_buf, MPI_CHAR, &status); + // on crée un flux sur le tableau de caractères: + istrstream * ent_inter = new istrstream(buffer_car,taille_buf) ; + // lecture de l'entête + string toto; + (*ent_inter) >> toto; + if (toto != "BI_MPI_IO_VariablesExporter_taille_buffer" ) + {cout << "\n **** erreur on devait lire : 'BI_MPI_IO_VariablesExporter_taille_buffer' " + << " et on lue "<< toto << " la suite n'est pas possible -> arret !! " + << "\n VariablesExporter::Lecture_base_info(... "<> taille_buffer_ioBI_MPI; + }; + // 3) ==== lecture du buffer et def du flux d'entrée associé + // puis lecture de base info sur le flux + { char * buffer_car = new char [taille_buffer_ioBI_MPI] ; + MPI_Status status1; + int ierr1 = MPI_File_read_all(ent_MPI, buffer_car, taille_buffer_ioBI_MPI, MPI_CHAR, &status1); + // on crée le flux sur le tableau de caractères: + istrstream * entrons = new istrstream(buffer_car,taille_buffer_ioBI_MPI) ; + this->Lecture_base_info(*entrons,cas); + }; + + }; + + // version MPI + void VariablesExporter::Ecriture_base_info(MPI_File& sort_MPI,const int cas) + { int proc_en_cours = ParaGlob::Monde()->rank(); + // 1) dans le cas d'un proc 0 ou i, on redéfinit le flux de sortie, pour bufferiser les infos en sortie + // qui sont ensuite sortie via MPI i-o à l'aide de la méthode Ecriture_base_info_MPI_IO + // les récupérations et les sorties sont effectuées de manière asynchrone par rapport aux autres proc + // 2) seul le proc 0 sort l'entête et les paramètres spécifiques de l'algo + + if (proc_en_cours == 0) // première partie dédiée proc 0 + {// dimensionnement de buffer_ioBI_MPI + std::ostringstream sort; // définition de sort + std::ostringstream * sortons = &sort; + this->Ecriture_base_info(sort,cas); + buffer_ioBI_MPI = sort.str(); // on sauvegarde + taille_buffer_ioBI_MPI = buffer_ioBI_MPI.size(); // def de la taille + // maintenant on va écrire la taille puis le buffer + union entier_caractere // par simplicité + { int n ; char ch[4]; }; + // === écriture dans flot string de la taille du buffer + // pour avoir une sortie lisible, on crée tout d'abord un buffer string avec les infos + std::ostringstream buf(std::ios_base::out); + buf << "\n BI_MPI_IO_VariablesExporter_taille_buffer \n"; + buf << taille_buffer_ioBI_MPI << " "; + + // le buffer du stream n'est pas pérenne il faut le récupérer + string buf_inter = buf.str(); // on récupère le buffer + int taille_buf = buf_inter.size(); + + // 1) ==== écriture de la place pour l'écriture de la taille du buffer + // on encapsule pour ré-utiliser la même trame + { + entier_caractere i_c; + i_c.n = taille_buf; + string deb("tout_offset "); + deb.insert(12,*(i_c.ch),4); // ce qui fait 16 caractères qu'on lira avant tout chose + // sortie sur fichier de la taille de buf2 + MPI_Status *status; // pour le retour + int ierr = MPI_File_write(sort_MPI,deb.c_str(),16,MPI_CHAR,status); + }; + + // 2) ==== écriture de la taille du buffer + { // sortie sur fichier de buf + MPI_Status *status; // pour le retour + int ierr = MPI_File_write(sort_MPI,buf_inter.c_str(),taille_buf,MPI_CHAR,status); + }; + + // 3) ==== enfin écriture du buffer + { MPI_Status *status; // pour le retour + int ierr = MPI_File_write(sort_MPI,buffer_ioBI_MPI.c_str() + ,taille_buffer_ioBI_MPI,MPI_CHAR,status); + }; + }; // fin du cas du proc 0 + + }; + #endif + // sortie du schemaXML: en fonction de enu void VariablesExporter::SchemaXML_VariablesExporters(UtilLecture * entreePrinc,const Enum_IO_XML enu) { diff --git a/Maillage/VariablesExporter.h b/Maillage/VariablesExporter.h index e447274..e62ab5a 100755 --- a/Maillage/VariablesExporter.h +++ b/Maillage/VariablesExporter.h @@ -69,6 +69,13 @@ #include "UtilLecture.h" #include "Enum_IO_XML.h" +#ifdef UTILISATION_MPI + #include "mpi.h" + #include + #include + namespace mpi = boost::mpi; +#endif + #include "LesMaillages.h" #include "Basiques.h" @@ -703,11 +710,16 @@ class VariablesExporter // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); +#ifdef UTILISATION_MPI + // version MPI + void Lecture_base_info(MPI_File& ent,const int cas); + void Ecriture_base_info(MPI_File& sort,const int cas); +#endif // sortie du schemaXML: en fonction de enu static void SchemaXML_VariablesExporters(UtilLecture * entreePrinc,const Enum_IO_XML enu) ; @@ -747,6 +759,12 @@ class VariablesExporter // -> une composante d'une variable globale de type multidimentionnel List_io list_var_glob_sur_grandeur_globale; + #ifdef UTILISATION_MPI + // pour les i/o retardées + std::string buffer_ioBI_MPI; // le buffer pour la sortie retardée + int taille_buffer_ioBI_MPI; // la taille qui est transmise par proc 0 + #endif + // méthodes diff --git a/Parametres/Banniere.h b/Parametres/Banniere.h index 70cb499..0703a57 100644 --- a/Parametres/Banniere.h +++ b/Parametres/Banniere.h @@ -72,11 +72,11 @@ class Banniere // METHODES PUBLIQUES : // affichage de la banniere sur la sortie passée en argument - static void Sortie_banniere(ofstream & sort); + static void Sortie_banniere(ostream & sort); // affichage de la banniere sur cout static void Sortie_banniere(); // passage en lecture de la banniere - static void Passage_lecture_banniere(ifstream& entr); + static void Passage_lecture_banniere(istream& entr); // retour du copie pirate static string CopiPirate(){return copipirate;}; diff --git a/Parametres/EnteteParaGlob.h b/Parametres/EnteteParaGlob.h index 1a07356..c128277 100644 --- a/Parametres/EnteteParaGlob.h +++ b/Parametres/EnteteParaGlob.h @@ -41,7 +41,7 @@ EnumLangue ParaGlob::langueHZ = FRANCAIS; // langue utilisée pour les entrées sorties int ParaGlob::nbComposantesTenseur = 1; // nombre de composantes par defaut a 1 int ParaGlob::nivImpression = 2; // niveau d'impression - string ParaGlob::nbVersion = "7.031" ; // numéro de version du logiciel + string ParaGlob::nbVersion = "7.033" ; // numéro de version du logiciel string ParaGlob::NbVersionsurfichier = ""; // numéro de version lue en entrée fichier int ParaGlob::nb_diggit_double_calcul= 17; // nombre de chiffre significatifs utilisé pour // l'affichage des double précision pour l'archivage diff --git a/Parametres/ParaAlgoControle.cc b/Parametres/ParaAlgoControle.cc index bcd1700..167e118 100755 --- a/Parametres/ParaAlgoControle.cc +++ b/Parametres/ParaAlgoControle.cc @@ -1300,7 +1300,7 @@ void ParaAlgoControle::Lecture_paraAlgoControle(UtilLecture & entreePrinc) // éventuellement est définit de manière spécifique pour chaque algorithme // dans les classes filles void ParaAlgoControle::Ecriture_base_info_Para - (ofstream& sort,const int cas) const + (ostream& sort,const int cas) const {// dans le cas particulier de cette classe il n'y a que les paramètres // du calcul qu'il faut sauvegarder sort << "\n"; @@ -1508,7 +1508,7 @@ void ParaAlgoControle::Ecriture_base_info_Para } }; // cas de la lecture spécifique à l'algorithme dans base_info -void ParaAlgoControle::Lecture_base_info_Para(ifstream& ent,const int cas) +void ParaAlgoControle::Lecture_base_info_Para(istream& ent,const int cas) { // dans le cas particulier de cette classe il n'y a que les paramètres // du calcul qu'il faut lire switch (cas) diff --git a/Parametres/ParaAlgoControle.h b/Parametres/ParaAlgoControle.h index 8fb75f3..0048a84 100644 --- a/Parametres/ParaAlgoControle.h +++ b/Parametres/ParaAlgoControle.h @@ -97,9 +97,9 @@ class ParaAlgoControle // éventuellement est définit de manière spécifique pour chaque algorithme // dans les classes filles void Ecriture_base_info_Para - (ofstream& sort,const int cas) const; + (ostream& sort,const int cas) const; // cas de la lecture spécifique à l'algorithme dans base_info - void Lecture_base_info_Para(ifstream& ent,const int cas); + void Lecture_base_info_Para(istream& ent,const int cas); // --- fonctions d'accès en lecture des paramètres // 1) ==== parametres de controle généraux pour la résolution de l'équilibre diff --git a/Parametres/ParaGlob.cc b/Parametres/ParaGlob.cc index 1f63e6a..8da406f 100644 --- a/Parametres/ParaGlob.cc +++ b/Parametres/ParaGlob.cc @@ -51,7 +51,9 @@ ParaGlob::ParaGlob() : ,etatDeLaLecturePointInfo(-1),demandeLectureSecondaireInPointInfo(0) ,listegrandeurs(),listegrandeurs_par_string() ,pt_temps_courant(NULL) -// ,tab_typeQuelconque_enum_etendu_modifier(false) + #ifdef UTILISATION_MPI + ,buffer_ioBI_MPI(),taille_buffer_ioBI_MPI() + #endif { dimensionPb = 1; // calcul du nombre de composantes des tenseurs en absolu @@ -96,7 +98,9 @@ ParaGlob::ParaGlob(int dim) : ,etatDeLaLecturePointInfo(-1),demandeLectureSecondaireInPointInfo(0) ,listegrandeurs(),listegrandeurs_par_string() ,pt_temps_courant(NULL) -// ,tab_typeQuelconque_enum_etendu_modifier(false) +#ifdef UTILISATION_MPI + ,buffer_ioBI_MPI(),taille_buffer_ioBI_MPI() +#endif { dimensionPb = dim; // calcul du nombre de composantes des tenseurs en absolu nbComposantesTenseur = 1; // cas par défaut 1D @@ -143,7 +147,9 @@ ParaGlob::ParaGlob (const ParaGlob & nd) : ,etatDeLaLecturePointInfo(nd.etatDeLaLecturePointInfo) ,demandeLectureSecondaireInPointInfo(nd.demandeLectureSecondaireInPointInfo) ,listegrandeurs(nd.listegrandeurs),listegrandeurs_par_string(nd.listegrandeurs_par_string) -// ,tab_typeQuelconque_enum_etendu_modifier(nd.tab_typeQuelconque_enum_etendu_modifier) +#ifdef UTILISATION_MPI + ,buffer_ioBI_MPI(nd.buffer_ioBI_MPI),taille_buffer_ioBI_MPI(nd.taille_buffer_ioBI_MPI) +#endif { // normalement on devrait pas utiliser le contructeur de copie cout << "\n ******* warning : normalement on ne devrait pas avoir plusieurs ParaGlob !!!! "; @@ -308,7 +314,7 @@ void ParaGlob::Change_Nb_diggit_double(int cas,int n_nb_dig) // lecture base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void ParaGlob::Lecture_base_info(ifstream& entr,const int cas) +void ParaGlob::Lecture_base_info(istream& entr,const int cas) { // a priori il n'y a pas de grandeur qui varie d'où lecture uniquement // dans le cas =1 if (cas == 1) @@ -331,7 +337,7 @@ void ParaGlob::Lecture_base_info(ifstream& entr,const int cas) { // dans le cas ou déjà la dimension est mauvaise // on signal qu'il y a un pb dans Paraglob cout << "\n*** erreur de lecture de dimension du problème ***\n" - << " ParaGlob::Lecture_base_info(ifstream& entr,const int cas)"; + << " ParaGlob::Lecture_base_info(istream& entr,const int cas)"; Sortie(1); }; // niveau d'impression des commentaires @@ -358,7 +364,7 @@ void ParaGlob::Lecture_base_info(ifstream& entr,const int cas) // écriture base info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void ParaGlob::Ecriture_base_info(ofstream& sort,const int cas) +void ParaGlob::Ecriture_base_info(ostream& sort,const int cas) { // a priori il n'y a pas de grandeur qui varie d'où sauvegarde uniquement // dans le cas =1 if (cas == 1) @@ -386,6 +392,119 @@ void ParaGlob::Ecriture_base_info(ofstream& sort,const int cas) sort << Nom_SousTypeCalcul(*ila) << " " << (*ili) << " "; } ; }; + +#ifdef UTILISATION_MPI + // version MPI + void ParaGlob::Lecture_base_info(MPI_File& ent_MPI,const int cas) + {// on commence par lire la taille du buffer d'offset + // tous les proc lisent + + // 1) ==== la taille de la place de la taille du buffer + int taille_buf = 0; // init + // on encapsule pour ré-utiliser la même trame + { char * buffer_car = new char [16] ; // def du tableau de travail + MPI_Status status; + int ierr = MPI_File_read_all(ent_MPI, buffer_car, 16, MPI_CHAR, &status); + // on crée un flux sur le tableau de caractères: + istrstream * ent_inter = new istrstream(buffer_car,16) ; + // lecture de l'entête + string toto; + (*ent_inter) >> toto; + if (toto != "tout_offset" ) + {cout << "\n **** erreur on devait lire : 'tout_offset' " + << " et on lue "<< toto << " la suite n'est pas possible -> arret !! " + << "\n ParaGlob::Lecture_base_info(... "<> toto >> taille_buf; + }; + // 2) ==== lecture de la taille du buffer + { char * buffer_car = new char [taille_buf] ; // def du tableau de travail + MPI_Status status; + int ierr = MPI_File_read_all(ent_MPI, buffer_car, taille_buf, MPI_CHAR, &status); + // on crée un flux sur le tableau de caractères: + istrstream * ent_inter = new istrstream(buffer_car,taille_buf) ; + // lecture de l'entête + string toto; + (*ent_inter) >> toto; + if (toto != "BI_MPI_IO_ParaGlob_taille_buffer" ) + {cout << "\n **** erreur on devait lire : 'BI_MPI_IO_ParaGlob_taille_buffer' " + << " et on lue "<< toto << " la suite n'est pas possible -> arret !! " + << "\n ParaGlob::Lecture_base_info(... "<> taille_buffer_ioBI_MPI; + }; + // 3) ==== lecture du buffer et def du flux d'entrée associé + // puis lecture de base info sur le flux + { char * buffer_car = new char [taille_buffer_ioBI_MPI] ; + MPI_Status status1; + int ierr1 = MPI_File_read_all(ent_MPI, buffer_car, taille_buffer_ioBI_MPI, MPI_CHAR, &status1); + // on crée le flux sur le tableau de caractères: + istrstream * entrons = new istrstream(buffer_car,taille_buffer_ioBI_MPI) ; + this->Lecture_base_info(*entrons,cas); + }; + + }; + + // version MPI + void ParaGlob::Ecriture_base_info(MPI_File& sort_MPI,const int cas) + { int proc_en_cours = ParaGlob::Monde()->rank(); + // 1) dans le cas d'un proc 0 ou i, on redéfinit le flux de sortie, pour bufferiser les infos en sortie + // qui sont ensuite sortie via MPI i-o à l'aide de la méthode Ecriture_base_info_MPI_IO + // les récupérations et les sorties sont effectuées de manière asynchrone par rapport aux autres proc + // 2) seul le proc 0 sort l'entête et les paramètres spécifiques de l'algo + + if (proc_en_cours == 0) // première partie dédiée proc 0 + {// dimensionnement de buffer_ioBI_MPI + std::ostringstream sort; // définition de sort + std::ostringstream * sortons = &sort; + this->Ecriture_base_info(sort,cas); + buffer_ioBI_MPI = sort.str(); // on sauvegarde + taille_buffer_ioBI_MPI = buffer_ioBI_MPI.size(); // def de la taille + // maintenant on va écrire la taille puis le buffer + union entier_caractere // par simplicité + { int n ; char ch[4]; }; + // === écriture dans flot string de la taille du buffer + // pour avoir une sortie lisible, on crée tout d'abord un buffer string avec les infos + std::ostringstream buf(std::ios_base::out); + buf << "\n BI_MPI_IO_ParaGlob_taille_buffer \n"; + buf << taille_buffer_ioBI_MPI << " "; + + // le buffer du stream n'est pas pérenne il faut le récupérer + string buf_inter = buf.str(); // on récupère le buffer + int taille_buf = buf_inter.size(); + + // 1) ==== écriture de la place pour l'écriture de la taille du buffer + // on encapsule pour ré-utiliser la même trame + { + entier_caractere i_c; + i_c.n = taille_buf; + string deb("tout_offset "); + deb.insert(12,*(i_c.ch),4); // ce qui fait 16 caractères qu'on lira avant tout chose + // sortie sur fichier de la taille de buf2 + MPI_Status *status; // pour le retour + int ierr = MPI_File_write(sort_MPI,deb.c_str(),16,MPI_CHAR,status); + }; + + // 2) ==== écriture de la taille du buffer + { // sortie sur fichier de buf + MPI_Status *status; // pour le retour + int ierr = MPI_File_write(sort_MPI,buf_inter.c_str(),taille_buf,MPI_CHAR,status); + }; + + // 3) ==== enfin écriture du buffer + { MPI_Status *status; // pour le retour + int ierr = MPI_File_write(sort_MPI,buffer_ioBI_MPI.c_str() + ,taille_buffer_ioBI_MPI,MPI_CHAR,status); + }; + }; // fin du cas du proc 0 + + }; +#endif + // ajout d'une nouvelle grandeur qui restera ensuite disponible void ParaGlob::Ajout_grandeur_consultable(void* grandeur, Enum_GrandeurGlobale enu) diff --git a/Parametres/ParaGlob.h b/Parametres/ParaGlob.h index a1f75f9..6c7b1a2 100644 --- a/Parametres/ParaGlob.h +++ b/Parametres/ParaGlob.h @@ -224,7 +224,7 @@ class ParaGlob // sur 5 caractères static string NbVersion() { return nbVersion;}; // affichage de la version sur la sortie passée en argument - static void Sortie_Version(ofstream & sort) + static void Sortie_Version(ostream & sort) { sort << "\n version " << nbVersion ;}; // affichage de la version sur cout static void Sortie_Version() @@ -250,7 +250,7 @@ class ParaGlob static bool Anglais() {return (langueHZ == ENGLISH);}; static bool Francais() {return (langueHZ == FRANCAIS);}; // affichage de la langue sur la sortie passée en argument - static void Sortie_Langue(ofstream & sort) { sort << "\n langue " << langueHZ ;}; + static void Sortie_Langue(ostream & sort) { sort << "\n langue " << langueHZ ;}; // ramène le nombre de diggit utilisé pour afficher des réels en double précision pour l'archivage // de calcul @@ -277,14 +277,20 @@ class ParaGlob static std::vector & Grandeurs_globales() {return grandeurs_globales;}; //----- lecture écriture dans base info ----- - // cas donne le niveau de la récupération + // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); + + #ifdef UTILISATION_MPI + // version MPI + void Lecture_base_info(MPI_File& ent,const int cas); + void Ecriture_base_info(MPI_File& sort,const int cas); + #endif //------------ gestion lecture dans le .info --------- // --- variable de lecture du .info, utilisées par des classes externes @@ -445,6 +451,10 @@ class ParaGlob // par le CPU, il s'agit d'une copie qui doit être mise à jour par Distribution_CPU const Tableau > >* tabb_indic_noeud; + // pour les i/o retardées + std::string buffer_ioBI_MPI; // le buffer pour la sortie retardée + int taille_buffer_ioBI_MPI; // la taille qui est transmise par proc 0 + #endif //------------ info sur le temps --------------- // c'est paraAlgoControle qui gère le temps, cependant paraglob sert de relais pour diff --git a/Parametres/banniere.cc b/Parametres/banniere.cc index 5a28c74..a9b62ab 100644 --- a/Parametres/banniere.cc +++ b/Parametres/banniere.cc @@ -63,7 +63,7 @@ Banniere::Construc_banniere Banniere::construc_ban; // affichage de la banniere sur la sortie passée en argument -void Banniere::Sortie_banniere(ofstream & sort) +void Banniere::Sortie_banniere(ostream & sort) { int taille = la_banniere.Taille(); for (int i=1;i<= taille;i++) sort << la_banniere(i); @@ -102,7 +102,7 @@ void Banniere::Sortie_banniere() }; // passage en lecture de la banniere -void Banniere::Passage_lecture_banniere(ifstream& entr) +void Banniere::Passage_lecture_banniere(istream& entr) { int taille = la_banniere.Taille(); string toto; for (int i=1;i<= taille;i++) diff --git a/References/LesReferences.cc b/References/LesReferences.cc index 7a3ef10..56be6cd 100644 --- a/References/LesReferences.cc +++ b/References/LesReferences.cc @@ -968,7 +968,7 @@ void LesReferences::Supprime_tour_lesRef_un_maillage(int num_mail, bool avec_dim // lecture base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesReferences::Lecture_base_info(ifstream& entr,const int cas) +void LesReferences::Lecture_base_info(istream& entr,const int cas) {bool fr = ParaGlob::Francais(); // pour simplifier // pour l'instant nous n'avons que des références fixes if (cas == 1) @@ -1029,7 +1029,7 @@ void LesReferences::Lecture_base_info(ifstream& entr,const int cas) // écriture base info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesReferences::Ecriture_base_info(ofstream& sort,const int cas) +void LesReferences::Ecriture_base_info(ostream& sort,const int cas) {bool fr = ParaGlob::Francais(); // pour simplifier // pour l'instant nous n'avons que des références fixes if (cas == 1) diff --git a/References/LesReferences.h b/References/LesReferences.h index 6be6a24..bda2903 100644 --- a/References/LesReferences.h +++ b/References/LesReferences.h @@ -196,11 +196,11 @@ class LesReferences // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected : // variable transitoires utilise pendant la lecture diff --git a/References/Reference.cc b/References/Reference.cc index e7537de..f5f628c 100644 --- a/References/Reference.cc +++ b/References/Reference.cc @@ -138,7 +138,7 @@ void Reference::Affiche () const #ifndef MISE_AU_POINT inline #endif -void Reference::Lect_int_base_info(ifstream& ent) +void Reference::Lect_int_base_info(istream& ent) { string toto; ent >> nom_ref >> nbmaille ; }; // cas donne le niveau de sauvegarde @@ -147,7 +147,7 @@ void Reference::Lect_int_base_info(ifstream& ent) #ifndef MISE_AU_POINT inline #endif -void Reference::Ecrit_int_base_info(ofstream& sort) +void Reference::Ecrit_int_base_info(ostream& sort) { sort << nom_ref <<" " << nbmaille << " "; }; diff --git a/References/Reference.h b/References/Reference.h index b113fe1..a5be44d 100644 --- a/References/Reference.h +++ b/References/Reference.h @@ -166,7 +166,7 @@ class Reference virtual void Affiche () const; // Affiche les donnees des références dans le flux passé en paramètre - virtual void Affiche_dans_lis(ofstream& sort) const =0 ; + virtual void Affiche_dans_lis(ostream& sort) const =0 ; // lecture d'une liste de reference virtual bool LectureReference(UtilLecture & entreePrinc) =0 ; @@ -181,11 +181,11 @@ class Reference // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info(ifstream& ent,const int cas) =0; + virtual void Lecture_base_info(istream& ent,const int cas) =0; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas) =0; + virtual void Ecriture_base_info(ostream& sort,const int cas) =0; protected : @@ -205,11 +205,11 @@ class Reference // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lect_int_base_info(ifstream& ent); + void Lect_int_base_info(istream& ent); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecrit_int_base_info(ofstream& sort); + void Ecrit_int_base_info(ostream& sort); }; /// @} // end of group diff --git a/References/ReferenceAF.cc b/References/ReferenceAF.cc index cbf3f18..ced2171 100644 --- a/References/ReferenceAF.cc +++ b/References/ReferenceAF.cc @@ -511,7 +511,7 @@ void ReferenceAF::Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas #ifndef MISE_AU_POINT inline #endif -void ReferenceAF::Lecture_base_info(ifstream& ent,const int cas) +void ReferenceAF::Lecture_base_info(istream& ent,const int cas) { // ici a priori il n'y a pas de de données supposées variables if (cas == 1) { @@ -532,7 +532,7 @@ void ReferenceAF::Lecture_base_info(ifstream& ent,const int cas) #ifndef MISE_AU_POINT inline #endif -void ReferenceAF::Ecriture_base_info(ofstream& sort,const int cas) +void ReferenceAF::Ecriture_base_info(ostream& sort,const int cas) { // ici a priori il n'y a pas de de données supposées variables if (cas == 1) { @@ -560,7 +560,7 @@ void ReferenceAF::Ecriture_base_info(ofstream& sort,const int cas) inline #endif // Affiche les donnees des références dans le flux passé en paramètre -void ReferenceAF::Affiche_dans_lis(ofstream& sort) const +void ReferenceAF::Affiche_dans_lis(ostream& sort) const { int taille_tab= tab_Elem.Taille(); // dans le cas où il n'y a pas de numéro associé à la référence on ne l'écrit pas if (taille_tab > 0 ) diff --git a/References/ReferenceAF.h b/References/ReferenceAF.h index b94724c..4f5ac23 100644 --- a/References/ReferenceAF.h +++ b/References/ReferenceAF.h @@ -170,7 +170,7 @@ class ReferenceAF : public Reference //-------- méthodes découlant de virtuelles ---------------- // Affiche les donnees des références dans le flux passé en paramètre - void Affiche_dans_lis(ofstream& sort) const ; + void Affiche_dans_lis(ostream& sort) const ; // lecture d'une liste de reference bool LectureReference(UtilLecture & entreePrinc); @@ -186,11 +186,11 @@ class ReferenceAF : public Reference // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected : diff --git a/References/ReferenceNE.cc b/References/ReferenceNE.cc index db08f1e..fcca68d 100644 --- a/References/ReferenceNE.cc +++ b/References/ReferenceNE.cc @@ -359,7 +359,7 @@ void ReferenceNE::Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int cas #ifndef MISE_AU_POINT inline #endif -void ReferenceNE::Lecture_base_info(ifstream& ent,const int cas) +void ReferenceNE::Lecture_base_info(istream& ent,const int cas) { // ici a priori il n'y a pas de de données supposées variables if (cas == 1) { @@ -375,7 +375,7 @@ void ReferenceNE::Lecture_base_info(ifstream& ent,const int cas) #ifndef MISE_AU_POINT inline #endif -void ReferenceNE::Ecriture_base_info(ofstream& sort,const int cas) +void ReferenceNE::Ecriture_base_info(ostream& sort,const int cas) { // ici a priori il n'y a pas de de données supposées variables if (cas == 1) { @@ -390,7 +390,7 @@ void ReferenceNE::Ecriture_base_info(ofstream& sort,const int cas) inline #endif // Affiche les donnees des références dans le flux passé en paramètre -void ReferenceNE::Affiche_dans_lis(ofstream& sort) const +void ReferenceNE::Affiche_dans_lis(ostream& sort) const { int taille_tab= tab_num.Taille(); // dans le cas où il n'y a pas de numéro associé à la référence on ne l'écrit pas if (taille_tab > 0 ) diff --git a/References/ReferenceNE.h b/References/ReferenceNE.h index 5518f6c..db9cdfb 100644 --- a/References/ReferenceNE.h +++ b/References/ReferenceNE.h @@ -154,7 +154,7 @@ class ReferenceNE : public Reference //-------- méthodes découlant de virtuelles ---------------- // Affiche les donnees des références dans le flux passé en paramètre - void Affiche_dans_lis(ofstream& sort) const ; + void Affiche_dans_lis(ostream& sort) const ; // lecture d'une liste de reference de noeuds ou d'éléments bool LectureReference(UtilLecture & entreePrinc); @@ -169,11 +169,11 @@ class ReferenceNE : public Reference // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected : diff --git a/References/ReferencePtiAF.cc b/References/ReferencePtiAF.cc index 56b6f88..1e7850d 100755 --- a/References/ReferencePtiAF.cc +++ b/References/ReferencePtiAF.cc @@ -547,7 +547,7 @@ void ReferencePtiAF::Info_commande_Ref(int nbMaxi,UtilLecture * entreePrinc,int #ifndef MISE_AU_POINT inline #endif -void ReferencePtiAF::Lecture_base_info(ifstream& ent,const int cas) +void ReferencePtiAF::Lecture_base_info(istream& ent,const int cas) { // ici a priori il n'y a pas de de données supposées variables if (cas == 1) { @@ -569,7 +569,7 @@ void ReferencePtiAF::Lecture_base_info(ifstream& ent,const int cas) #ifndef MISE_AU_POINT inline #endif -void ReferencePtiAF::Ecriture_base_info(ofstream& sort,const int cas) +void ReferencePtiAF::Ecriture_base_info(ostream& sort,const int cas) { // ici a priori il n'y a pas de de données supposées variables if (cas == 1) { @@ -599,7 +599,7 @@ void ReferencePtiAF::Ecriture_base_info(ofstream& sort,const int cas) inline #endif // Affiche les donnees des références dans le flux passé en paramètre -void ReferencePtiAF::Affiche_dans_lis(ofstream& sort) const +void ReferencePtiAF::Affiche_dans_lis(ostream& sort) const { int taille_tab= tab_Elem.Taille(); // dans le cas où il n'y a pas de numéro associé à la référence on ne l'écrit pas if (taille_tab > 0 ) diff --git a/References/ReferencePtiAF.h b/References/ReferencePtiAF.h index 10e1a64..0bd90f0 100755 --- a/References/ReferencePtiAF.h +++ b/References/ReferencePtiAF.h @@ -182,7 +182,7 @@ class ReferencePtiAF : public Reference //-------- méthodes découlant de virtuelles ---------------- // Affiche les donnees des références dans le flux passé en paramètre - void Affiche_dans_lis(ofstream& sort) const ; + void Affiche_dans_lis(ostream& sort) const ; // lecture d'une liste de reference bool LectureReference(UtilLecture & entreePrinc); @@ -198,11 +198,11 @@ class ReferencePtiAF : public Reference // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); protected : diff --git a/Resolin/Resolution_Condi/Condilineaire.cc b/Resolin/Resolution_Condi/Condilineaire.cc index f45c85a..eb69106 100644 --- a/Resolin/Resolution_Condi/Condilineaire.cc +++ b/Resolin/Resolution_Condi/Condilineaire.cc @@ -149,7 +149,7 @@ void Condilineaire::Affiche() const //----- lecture écriture de restart ----- void Condilineaire::Lecture_base_info - (Tableau & numMaillage, ifstream& ent,Tableau & numNoeud) + (Tableau & numMaillage, istream& ent,Tableau & numNoeud) { // lecture du tableau pt.Entree(ent); // le tableau des coefficients @@ -169,7 +169,7 @@ void Condilineaire::Lecture_base_info // lecture du numéro d'ordre du ddl modifié dans noeud ent >> iddl; }; -void Condilineaire::Ecriture_base_info(ofstream& sort) +void Condilineaire::Ecriture_base_info(ostream& sort) { // sauvegarde du tableau pt.Sortir(sort); // le tableau des coefficients diff --git a/Resolin/Resolution_Condi/Condilineaire.h b/Resolin/Resolution_Condi/Condilineaire.h index feb8db8..28f1d43 100644 --- a/Resolin/Resolution_Condi/Condilineaire.h +++ b/Resolin/Resolution_Condi/Condilineaire.h @@ -177,8 +177,8 @@ class Condilineaire // noeud sur lequel s'applique la condition limite // il est nécessaire ensuite d'utiliser la fonction Change_noeud pour` // attibuer le noeud - void Lecture_base_info(Tableau & numMaillage, ifstream& ent,Tableau & numNoeud) ; - void Ecriture_base_info(ofstream& sort) ; + void Lecture_base_info(Tableau & numMaillage, istream& ent,Tableau & numNoeud) ; + void Ecriture_base_info(ostream& sort) ; #ifdef UTILISATION_MPI // spécifique au calcul parallèle // stockage dans un unique vecteur, des infos à partir de l'indice rang inclus // correspond à une sérialisation des infos diff --git a/Resultats/Resultats.cc b/Resultats/Resultats.cc index 114bd0d..4f83eaa 100644 --- a/Resultats/Resultats.cc +++ b/Resultats/Resultats.cc @@ -385,7 +385,7 @@ void Resultats::SortieInfo //----- lecture écriture base info ----- // lecture base info -void Resultats::Lect_result_base_info(ifstream& ent,const int cas) +void Resultats::Lect_result_base_info(istream& ent,const int cas) { if (cas == 1) { string toto; // lecture de l'entête et vérification @@ -410,21 +410,22 @@ void Resultats::Lect_result_base_info(ifstream& ent,const int cas) }; // écriture base info -void Resultats::Ecri_result_base_info(ofstream& sort,const int cas) +void Resultats::Ecri_result_base_info(ostream& sort,const int cas) { if (cas == 1) - { sort << "\n ****Resultats "<< pas_de_sortie <<" \n"; - // sortie des tableau des regions - // tout d'abord le nombre d'élément et un identificateur - sort << "liste_region:_nb= " << tabRegion.size() << "\n"; - // on balaie la liste - list >::const_iterator i; - for (i=tabRegion.begin() ; i != tabRegion.end(); i++) - sort << (*i) ; - sort << "\n"; - // parametres de gestion - sort << "copie: " << copie << " "; - } - }; + { sort << "\n ****Resultats "<< pas_de_sortie <<" \n"; + // sortie des tableau des regions + // tout d'abord le nombre d'élément et un identificateur + sort << "liste_region:_nb= " << tabRegion.size() << "\n"; + // on balaie la liste + list >::const_iterator i; + for (i=tabRegion.begin() ; i != tabRegion.end(); i++) + sort << (*i) ; + sort << "\n"; + // parametres de gestion + sort << "copie: " << copie << " "; + }; + sort << "\n\n" << endl; // pour passer une ligne et avoir une séparation plus claireflush; +}; // =============================== fonctions privates ============== diff --git a/Resultats/Resultats.h b/Resultats/Resultats.h index 7089fcd..341ad7d 100644 --- a/Resultats/Resultats.h +++ b/Resultats/Resultats.h @@ -112,11 +112,11 @@ class Resultats // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lect_result_base_info(ifstream& ent,const int cas); + void Lect_result_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecri_result_base_info(ofstream& sort,const int cas); + void Ecri_result_base_info(ostream& sort,const int cas); private : diff --git a/TypeBase/Basiques.cc b/TypeBase/Basiques.cc index 95cfbd0..b7d3028 100644 --- a/TypeBase/Basiques.cc +++ b/TypeBase/Basiques.cc @@ -44,7 +44,7 @@ short int QuatreEntiers::impre_schem_XML=0; short int CinqEntiers::impre_schem_XML=0; // sortie du schemaXML: en fonction de enu -void DeuxEntiers::SchemaXML_DeuxEntiers(ofstream& sort,const Enum_IO_XML enu) const +void DeuxEntiers::SchemaXML_DeuxEntiers(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -76,7 +76,7 @@ ostream & DeuxEntiers::EcritXML_DeuxEntiers(ostream & sort) }; // sortie du schemaXML: en fonction de enu -void DeuxDoubles::SchemaXML_DeuxDoubles(ofstream& sort,const Enum_IO_XML enu) const +void DeuxDoubles::SchemaXML_DeuxDoubles(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -111,7 +111,7 @@ ostream & DeuxDoubles::EcritXML_DeuxDoubles(ostream & sort) // sortie du schemaXML: en fonction de enu -void Entier_et_Double::SchemaXML_Entier_et_Double(ofstream& sort,const Enum_IO_XML enu) const +void Entier_et_Double::SchemaXML_Entier_et_Double(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -145,7 +145,7 @@ ostream & Entier_et_Double::EcritXML_Entier_et_Double(ostream & sort) // sortie du schemaXML: en fonction de enu -void Deux_String::SchemaXML_Deux_String(ofstream& sort,const Enum_IO_XML enu) const +void Deux_String::SchemaXML_Deux_String(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -179,7 +179,7 @@ ostream & Deux_String::EcritXML_Deux_String(ostream & sort) // sortie du schemaXML: en fonction de enu -void String_et_entier::SchemaXML_String_et_entier(ofstream& sort,const Enum_IO_XML enu) const +void String_et_entier::SchemaXML_String_et_entier(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -213,7 +213,7 @@ ostream & String_et_entier::EcritXML_String_et_entier(ostream & sort) // sortie du schemaXML: en fonction de enu -void Trois_String::SchemaXML_Trois_String(ofstream& sort,const Enum_IO_XML enu) const +void Trois_String::SchemaXML_Trois_String(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -247,7 +247,7 @@ ostream & Trois_String::EcritXML_Trois_String(ostream & sort) }; // sortie du schemaXML: en fonction de enu -void Quatre_string_un_entier::SchemaXML_Quatre_string_un_entier(ofstream& sort,const Enum_IO_XML enu) const +void Quatre_string_un_entier::SchemaXML_Quatre_string_un_entier(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -284,7 +284,7 @@ ostream & Quatre_string_un_entier::EcritXML_Quatre_string_un_entier(ostream & so // sortie du schemaXML: en fonction de enu -void TroisEntiers::SchemaXML_TroisEntiers(ofstream& sort,const Enum_IO_XML enu) const +void TroisEntiers::SchemaXML_TroisEntiers(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -319,7 +319,7 @@ ostream & TroisEntiers::EcritXML_TroisEntiers(ostream & sort) // sortie du schemaXML: en fonction de enu -void Deux_String_un_entier::SchemaXML_Deux_String_un_entier(ofstream& sort,const Enum_IO_XML enu) const +void Deux_String_un_entier::SchemaXML_Deux_String_un_entier(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -353,7 +353,7 @@ ostream & Deux_String_un_entier::EcritXML_Deux_String_un_entier(ostream & sort) }; // sortie du schemaXML: en fonction de enu -void QuatreEntiers::SchemaXML_QuatreEntiers(ofstream& sort,const Enum_IO_XML enu) const +void QuatreEntiers::SchemaXML_QuatreEntiers(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: @@ -391,7 +391,7 @@ ostream & QuatreEntiers::EcritXML_QuatreEntiers(ostream & sort) // sortie du schemaXML: en fonction de enu -void CinqEntiers::SchemaXML_CinqEntiers(ofstream& sort,const Enum_IO_XML enu) const +void CinqEntiers::SchemaXML_CinqEntiers(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: diff --git a/TypeBase/Basiques.h b/TypeBase/Basiques.h index 2ca46e1..2a65bd6 100644 --- a/TypeBase/Basiques.h +++ b/TypeBase/Basiques.h @@ -128,7 +128,7 @@ class DeuxEntiers bool operator < (const DeuxEntiers& a) const { return (this->deux < a.deux);}; bool operator <= (const DeuxEntiers& a) const { return (this->deux <= a.deux);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_DeuxEntiers(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_DeuxEntiers(ostream& sort,const Enum_IO_XML enu) const ; }; /// @} // end of group @@ -185,7 +185,7 @@ class DeuxDoubles { if (( un==a.un) && (deux==a.deux)) return true; else return false;}; bool operator != ( const DeuxDoubles& a) const { return !(*this == a);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_DeuxDoubles(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_DeuxDoubles(ostream& sort,const Enum_IO_XML enu) const ; }; /// @} // end of group @@ -243,7 +243,7 @@ class Entier_et_Double { if (( n==a.n) && (x==a.x)) return true; else return false;}; bool operator != (const Entier_et_Double& a) const { return !(*this == a);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_Entier_et_Double(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_Entier_et_Double(ostream& sort,const Enum_IO_XML enu) const ; // surchage de l'opérateur de comparaison : ici elle se fait uniquement sur le double bool operator > (const Entier_et_Double& a) const { return (this->x > a.x);}; bool operator >= (const Entier_et_Double& a) const { return (this->x >= a.x);}; @@ -305,7 +305,7 @@ class Deux_String { if (( nom1 == a.nom1) && (nom2 == a.nom2)) return true; else return false;}; bool operator != (const Deux_String& a) const { return !(*this == a);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_Deux_String(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_Deux_String(ostream& sort,const Enum_IO_XML enu) const ; // surchage de l'opérateur de comparaison : ici elle se fait uniquement sur le premier nom = nom1 bool operator > (const Deux_String& a) const { return (this->nom1 > a.nom1);}; bool operator >= (const Deux_String& a) const { return (this->nom1 >= a.nom1);}; @@ -368,7 +368,7 @@ class String_et_entier { if (( nom == a.nom) && (n == a.n)) return true; else return false;}; bool operator != (const String_et_entier& a) const { return !(*this == a);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_String_et_entier(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_String_et_entier(ostream& sort,const Enum_IO_XML enu) const ; }; /// @} // end of group @@ -425,7 +425,7 @@ class Trois_String { if (( nom1 == a.nom1) && (nom2 == a.nom2)&& (nom3 == a.nom3)) return true; else return false;}; bool operator != (const Trois_String& a) const { return !(*this == a);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_Trois_String(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_Trois_String(ostream& sort,const Enum_IO_XML enu) const ; // surchage de l'opérateur de comparaison : ici elle se fait uniquement sur le premier nom = nom1 bool operator > (const Trois_String& a) const { return (this->nom1 > a.nom1);}; bool operator >= (const Trois_String& a) const { return (this->nom1 >= a.nom1);}; @@ -491,7 +491,7 @@ class Quatre_string_un_entier return true; else return false;}; bool operator != (const Quatre_string_un_entier& a) const { return !(*this == a);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_Quatre_string_un_entier(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_Quatre_string_un_entier(ostream& sort,const Enum_IO_XML enu) const ; // surchage de l'opérateur de comparaison : ici elle se fait par decroissance // est uniquement intéressante pour classer, bool operator > (const Quatre_string_un_entier& a) const @@ -778,7 +778,7 @@ class TroisEntiers } }; // sortie du schemaXML: en fonction de enu - void SchemaXML_TroisEntiers(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_TroisEntiers(ostream& sort,const Enum_IO_XML enu) const ; }; /// @} // end of group @@ -840,7 +840,7 @@ class Deux_String_un_entier return true; else return false;}; bool operator != (const Deux_String_un_entier& a) const { return !(*this == a);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_Deux_String_un_entier(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_Deux_String_un_entier(ostream& sort,const Enum_IO_XML enu) const ; // surchage de l'opérateur de comparaison : ici elle se fait par decroissance // est uniquement intéressante pour classer, bool operator > (const Deux_String_un_entier& a) const @@ -1095,7 +1095,7 @@ class QuatreEntiers } }; // sortie du schemaXML: en fonction de enu - void SchemaXML_QuatreEntiers(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_QuatreEntiers(ostream& sort,const Enum_IO_XML enu) const ; }; /// @} // end of group @@ -1285,7 +1285,7 @@ class CinqEntiers } }; // sortie du schemaXML: en fonction de enu - void SchemaXML_CinqEntiers(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_CinqEntiers(ostream& sort,const Enum_IO_XML enu) const ; }; /// @} // end of group diff --git a/TypeBase/Ponderation.cc b/TypeBase/Ponderation.cc index 398060c..3c77622 100755 --- a/TypeBase/Ponderation.cc +++ b/TypeBase/Ponderation.cc @@ -140,7 +140,7 @@ void Ponderation_Consultable::Verif_complet() const // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Ponderation_Consultable::Lecture_base_info(ifstream& ent,const int cas,LesCourbes1D& lesCourbes1D) +void Ponderation_Consultable::Lecture_base_info(istream& ent,const int cas,LesCourbes1D& lesCourbes1D) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs string nom; if (cas == 1) @@ -165,7 +165,7 @@ void Ponderation_Consultable::Lecture_base_info(ifstream& ent,const int cas,LesC // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Ponderation_Consultable::Ecriture_base_info(ofstream& sort,const int cas) +void Ponderation_Consultable::Ecriture_base_info(ostream& sort,const int cas) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs if (cas == 1) { sort << "\n Ponderation_Consultable " << tab_nom_fonction ; @@ -386,7 +386,7 @@ void Ponderation_GGlobal::Affiche() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Ponderation_GGlobal::Lecture_base_info(ifstream& ent,const int cas,LesFonctions_nD& lesFonctionsnD) +void Ponderation_GGlobal::Lecture_base_info(istream& ent,const int cas,LesFonctions_nD& lesFonctionsnD) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs string nom; if (cas == 1) @@ -406,7 +406,7 @@ void Ponderation_GGlobal::Lecture_base_info(ifstream& ent,const int cas,LesFonct // idem mais sans définition de la courbe: // correspond au cas de la sauvegarde avec san_courbe = true -void Ponderation_GGlobal::Lecture_base_info(ifstream& ent,const int cas) +void Ponderation_GGlobal::Lecture_base_info(istream& ent,const int cas) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs string nom; if (cas == 1) @@ -421,7 +421,7 @@ void Ponderation_GGlobal::Lecture_base_info(ifstream& ent,const int cas) // sans_courbe: indique si on sauve oui ou non la courbe elle-même // true: on sauve la courbe // false : on sauve uniquement le nom de la courbe -void Ponderation_GGlobal::Ecriture_base_info(ofstream& sort,const int cas,bool sans_courbe) +void Ponderation_GGlobal::Ecriture_base_info(ostream& sort,const int cas,bool sans_courbe) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs if (cas == 1) { sort << "\n Ponderation_GGlobal " << nom_fonction; @@ -437,7 +437,7 @@ void Ponderation_GGlobal::Ecriture_base_info(ofstream& sort,const int cas,bool s }; // sortie du schemaXML: en fonction de enu -void Ponderation_GGlobal::SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu) +void Ponderation_GGlobal::SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu) { }; @@ -653,7 +653,7 @@ void Ponderation_TypeQuelconque::Verif_complet() const // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Ponderation_TypeQuelconque::Lecture_base_info(ifstream& ent,const int cas,LesFonctions_nD& lesFonctionsnD) +void Ponderation_TypeQuelconque::Lecture_base_info(istream& ent,const int cas,LesFonctions_nD& lesFonctionsnD) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs string nom; if (cas == 1) @@ -683,7 +683,7 @@ void Ponderation_TypeQuelconque::Lecture_base_info(ifstream& ent,const int cas,L // idem mais sans définition de la courbe: // correspond au cas de la sauvegarde avec san_courbe = true -void Ponderation_TypeQuelconque::Lecture_base_info(ifstream& ent,const int cas) +void Ponderation_TypeQuelconque::Lecture_base_info(istream& ent,const int cas) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs string nom; if (cas == 1) @@ -708,7 +708,7 @@ void Ponderation_TypeQuelconque::Lecture_base_info(ifstream& ent,const int cas) // sans_courbe: indique si on sauve oui ou non la courbe elle-même // true: on sauve la courbe // false : on sauve uniquement le nom de la courbe -void Ponderation_TypeQuelconque::Ecriture_base_info(ofstream& sort,const int cas,bool sans_courbe) +void Ponderation_TypeQuelconque::Ecriture_base_info(ostream& sort,const int cas,bool sans_courbe) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs if (cas == 1) { sort << "\n Ponderation_TypeQuelconque " << nom_fonction; @@ -730,7 +730,7 @@ void Ponderation_TypeQuelconque::Ecriture_base_info(ofstream& sort,const int cas }; // sortie du schemaXML: en fonction de enu -void Ponderation_TypeQuelconque::SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu) +void Ponderation_TypeQuelconque::SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu) { }; @@ -1164,7 +1164,7 @@ double Ponderation::CalculPonderMultiplicatif(const PtIntegMecaInterne& ptintmec // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Ponderation::Lecture_base_info(ifstream& ent,const int cas,LesCourbes1D& lesCourbes1D) +void Ponderation::Lecture_base_info(istream& ent,const int cas,LesCourbes1D& lesCourbes1D) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs string nom; if (cas == 1) @@ -1190,7 +1190,7 @@ void Ponderation::Lecture_base_info(ifstream& ent,const int cas,LesCourbes1D& le // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Ponderation::Ecriture_base_info(ofstream& sort,const int cas) +void Ponderation::Ecriture_base_info(ostream& sort,const int cas) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs if (cas == 1) { sort << "\n Ponderation " << "nom_courbes " << tab_nom_fonction; @@ -1208,7 +1208,7 @@ void Ponderation::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Ponderation::SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu) +void Ponderation::SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu) { }; @@ -1351,7 +1351,7 @@ double Ponderation_temps::CalculPonder() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Ponderation_temps::Lecture_base_info(ifstream& ent,const int cas,LesCourbes1D& lesCourbes1D) +void Ponderation_temps::Lecture_base_info(istream& ent,const int cas,LesCourbes1D& lesCourbes1D) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs string nom; if (cas == 1) @@ -1370,7 +1370,7 @@ void Ponderation_temps::Lecture_base_info(ifstream& ent,const int cas,LesCourbes }; // idem mais sans définition de la courbe -void Ponderation_temps::Lecture_base_info(ifstream& ent,const int cas) +void Ponderation_temps::Lecture_base_info(istream& ent,const int cas) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs string nom; if (cas == 1) @@ -1384,7 +1384,7 @@ void Ponderation_temps::Lecture_base_info(ifstream& ent,const int cas) // sans_courbe: indique si on sauve oui ou non la courbe elle-même // true: on sauve la courbe // false : on sauve uniquement le nom de la courbe -void Ponderation_temps::Ecriture_base_info(ofstream& sort,const int cas,bool sans_courbe) +void Ponderation_temps::Ecriture_base_info(ostream& sort,const int cas,bool sans_courbe) { // ici on ne sort que pour le cas 1, ce qui fait qu'en restart on peut changer les valeurs if (cas == 1) { sort << "\n Ponderation_temps " << nom_fonction; diff --git a/TypeBase/Ponderation.h b/TypeBase/Ponderation.h index 04d660d..f80a757 100755 --- a/TypeBase/Ponderation.h +++ b/TypeBase/Ponderation.h @@ -106,13 +106,13 @@ // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesCourbes1D& lesCourbes1D); + void Lecture_base_info(istream& ent,const int cas,LesCourbes1D& lesCourbes1D); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); protected: Tableau type_grandeur_Consultable; // à chaque grandeur est associé une fonction 1D @@ -163,19 +163,19 @@ // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesFonctions_nD& lesFonctionsnD); + void Lecture_base_info(istream& ent,const int cas,LesFonctions_nD& lesFonctionsnD); // idem mais sans définition de la courbe: // correspond au cas de la sauvegarde avec san_courbe = true - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) // sans_courbe: indique si on sauve oui ou non la courbe elle-même // true: on sauve la courbe // false : on sauve uniquement le nom de la courbe - void Ecriture_base_info(ofstream& sort,const int cas,bool sans_courbe=false); + void Ecriture_base_info(ostream& sort,const int cas,bool sans_courbe=false); // sortie du schemaXML: en fonction de enu - void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); protected: string nom_fonction; // le nom de la fonction, sert en particulier pour une définition de la fonction @@ -231,19 +231,19 @@ // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesFonctions_nD& lesFonctionsnD); + void Lecture_base_info(istream& ent,const int cas,LesFonctions_nD& lesFonctionsnD); // idem mais sans définition de la fonction nD: // correspond au cas de la sauvegarde avec san_courbe = true - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) // sans_fct: indique si on sauve oui ou non la fonction elle-même // true: on sauve la fonction // false : on sauve uniquement le nom de la fonction - void Ecriture_base_info(ofstream& sort,const int cas,bool sans_fct=false); + void Ecriture_base_info(ostream& sort,const int cas,bool sans_fct=false); // sortie du schemaXML: en fonction de enu - void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); protected: string nom_fonction; // le nom de la fonction, sert en particulier pour une définition de la fonction @@ -335,13 +335,13 @@ // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesCourbes1D& lesCourbes1D); + void Lecture_base_info(istream& ent,const int cas,LesCourbes1D& lesCourbes1D); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); protected: Tableau type_grandeur; // à chaque grandeur est associé une fonction 1D @@ -397,19 +397,19 @@ // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesCourbes1D& lesCourbes1D); + void Lecture_base_info(istream& ent,const int cas,LesCourbes1D& lesCourbes1D); // idem mais sans définition de la courbe: // correspond au cas de la sauvegarde avec sans_courbe = true - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) // sans_courbe: indique si on sauve oui ou non la courbe elle-même // true: on sauve la courbe // false : on sauve uniquement le nom de la courbe - void Ecriture_base_info(ofstream& sort,const int cas,bool sans_courbe=false); + void Ecriture_base_info(ostream& sort,const int cas,bool sans_courbe=false); // sortie du schemaXML: en fonction de enu - void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); protected: string nom_fonction; // le nom de la fonction, sert en particulier pour une définition de la fonction diff --git a/TypeBase/Temps_CPU_HZpp.cc b/TypeBase/Temps_CPU_HZpp.cc index 91ca7e5..66f5533 100755 --- a/TypeBase/Temps_CPU_HZpp.cc +++ b/TypeBase/Temps_CPU_HZpp.cc @@ -159,7 +159,7 @@ ostream & operator << (ostream & sort , const Temps_CPU_HZpp & a) // sortie du schemaXML: en fonction de enu -void Temps_CPU_HZpp::SchemaXML_Temps_CPU_HZpp(ofstream& sort,const Enum_IO_XML enu) const +void Temps_CPU_HZpp::SchemaXML_Temps_CPU_HZpp(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: diff --git a/TypeBase/Temps_CPU_HZpp.h b/TypeBase/Temps_CPU_HZpp.h index c812e4d..5edc6a9 100755 --- a/TypeBase/Temps_CPU_HZpp.h +++ b/TypeBase/Temps_CPU_HZpp.h @@ -274,7 +274,7 @@ class Temps_CPU_HZpp bool operator <= (const Temps_CPU_HZpp& a) const { return (this->temps_user <= a.temps_user);}; // sortie du schemaXML: en fonction de enu - void SchemaXML_Temps_CPU_HZpp(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_Temps_CPU_HZpp(ostream& sort,const Enum_IO_XML enu) const ; diff --git a/TypeBase/Temps_CPU_HZpp_3.cc b/TypeBase/Temps_CPU_HZpp_3.cc index babaca4..fc0cc8b 100755 --- a/TypeBase/Temps_CPU_HZpp_3.cc +++ b/TypeBase/Temps_CPU_HZpp_3.cc @@ -203,7 +203,7 @@ ostream & operator << (ostream & sort , const Temps_CPU_HZpp_3 & a) // sortie du schemaXML: en fonction de enu -void Temps_CPU_HZpp_3::SchemaXML_Temps_CPU_HZpp_3(ofstream& sort,const Enum_IO_XML enu) const +void Temps_CPU_HZpp_3::SchemaXML_Temps_CPU_HZpp_3(ostream& sort,const Enum_IO_XML enu) const {// sortie balisée simple switch (enu) {case XML_TYPE_GLOBAUX: diff --git a/TypeBase/Temps_CPU_HZpp_3.h b/TypeBase/Temps_CPU_HZpp_3.h index 09a228a..2fd72ee 100755 --- a/TypeBase/Temps_CPU_HZpp_3.h +++ b/TypeBase/Temps_CPU_HZpp_3.h @@ -121,7 +121,7 @@ class Temps_CPU_HZpp_3 ostream & EcritXML_Temps_CPU_HZpp_3(ostream & sort); // sortie du schemaXML: en fonction de enu - void SchemaXML_Temps_CPU_HZpp_3(ofstream& sort,const Enum_IO_XML enu) const ; + void SchemaXML_Temps_CPU_HZpp_3(ostream& sort,const Enum_IO_XML enu) const ; private : diff --git a/Util/Algo_zero.cc b/Util/Algo_zero.cc index ad7f820..c21bfcc 100644 --- a/Util/Algo_zero.cc +++ b/Util/Algo_zero.cc @@ -94,7 +94,7 @@ void Algo_zero::Affiche() const // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Algo_zero::Lecture_base_info (ifstream& ent,const int cas) +void Algo_zero::Lecture_base_info (istream& ent,const int cas) { if (cas == 1) {string nom; ent >> nom; @@ -119,7 +119,7 @@ void Algo_zero::Lecture_base_info (ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Algo_zero::Ecriture_base_info(ofstream& sort,const int cas) +void Algo_zero::Ecriture_base_info(ostream& sort,const int cas) { if (cas==1) {sort << "\n Algo_zero:_para:" << " prec_res_abs= " << prec_res_abs diff --git a/Util/Algo_zero.h b/Util/Algo_zero.h index 80bd30c..420edde 100644 --- a/Util/Algo_zero.h +++ b/Util/Algo_zero.h @@ -221,11 +221,11 @@ class Algo_zero /// cas donne le niveau de la récupération /// = 1 : on récupère tout /// = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); /// cas donne le niveau de sauvegarde /// = 1 : on sauvegarde tout /// = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); private : diff --git a/Util/CharUtil.cc b/Util/CharUtil.cc index 07a67c2..edc2f8d 100644 --- a/Util/CharUtil.cc +++ b/Util/CharUtil.cc @@ -373,7 +373,7 @@ string lect_o_n(bool avec_ecriture) // lecture du prochain caractère non espace et non vide dans le flot sans modifier le flot // en remplacement de la méthode peek qui ne marche pas avec code warrior // si pb ou aucun caractère, retour du caractère "espacement" - char Picococar(ifstream& entr) + char Picococar(istream& entr) { char car; // = flot.peek(); entr >> car; // si pb cela signifie qu'en fait la ligne est terminée donc on s'arrête diff --git a/Util/CharUtil.h b/Util/CharUtil.h index 8ebc057..0f06224 100644 --- a/Util/CharUtil.h +++ b/Util/CharUtil.h @@ -120,7 +120,7 @@ /// lecture du prochain caractère non espace et non vide dans le flot sans modifier le flot /// en remplacement de la méthode peek qui ne marche pas avec code warrior /// si pb ou aucun caractère, retour du caractère "espacement" - char Picococar(ifstream& entr); + char Picococar(istream& entr); #ifndef ENLINUX_STREAM char Picococar(istringstream& entr); #else diff --git a/Util/Courbes/Courbe1D.h b/Util/Courbes/Courbe1D.h index 3fd8947..ac26839 100644 --- a/Util/Courbes/Courbe1D.h +++ b/Util/Courbes/Courbe1D.h @@ -205,13 +205,13 @@ class Courbe1D /// cas donne le niveau de la récupération /// = 1 : on récupère tout /// = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info(ifstream& ent,const int cas) = 0; + virtual void Lecture_base_info(istream& ent,const int cas) = 0; /// cas donne le niveau de sauvegarde /// = 1 : on sauvegarde tout /// = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas) = 0; + virtual void Ecriture_base_info(ostream& sort,const int cas) = 0; /// sortie du schemaXML: en fonction de enu - virtual void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) = 0; + virtual void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) = 0; // ---------- static --------- diff --git a/Util/Courbes/CourbePolyHermite1D.cc b/Util/Courbes/CourbePolyHermite1D.cc index 55da313..0448b3e 100755 --- a/Util/Courbes/CourbePolyHermite1D.cc +++ b/Util/Courbes/CourbePolyHermite1D.cc @@ -793,7 +793,7 @@ void CourbePolyHermite1D::Change_tabPoints(Tableau & pt) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void CourbePolyHermite1D::Lecture_base_info(ifstream& ent,const int cas) +void CourbePolyHermite1D::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -817,7 +817,7 @@ void CourbePolyHermite1D::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void CourbePolyHermite1D::Ecriture_base_info(ofstream& sort,const int cas) +void CourbePolyHermite1D::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << "\n "; @@ -827,7 +827,7 @@ void CourbePolyHermite1D::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void CourbePolyHermite1D::SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) +void CourbePolyHermite1D::SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/CourbePolyHermite1D.h b/Util/Courbes/CourbePolyHermite1D.h index 338e7ce..3f5f7ad 100755 --- a/Util/Courbes/CourbePolyHermite1D.h +++ b/Util/Courbes/CourbePolyHermite1D.h @@ -154,13 +154,13 @@ class CourbePolyHermite1D : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - virtual void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + virtual void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; // ------------ méthodes particulières à la fonction poly-linéaire --------- // ramène le nombre de point de la polyligne diff --git a/Util/Courbes/CourbePolyLineaire.cc b/Util/Courbes/CourbePolyLineaire.cc index f0635cb..01d197a 100755 --- a/Util/Courbes/CourbePolyLineaire.cc +++ b/Util/Courbes/CourbePolyLineaire.cc @@ -530,7 +530,7 @@ void CourbePolyLineaire1D::Change_tabPoints(Tableau & pt) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void CourbePolyLineaire1D::Lecture_base_info(ifstream& ent,const int cas) +void CourbePolyLineaire1D::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -556,7 +556,7 @@ void CourbePolyLineaire1D::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void CourbePolyLineaire1D::Ecriture_base_info(ofstream& sort,const int cas) +void CourbePolyLineaire1D::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << "\n " @@ -568,7 +568,7 @@ void CourbePolyLineaire1D::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void CourbePolyLineaire1D::SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) +void CourbePolyLineaire1D::SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/CourbePolyLineaire1D.h b/Util/Courbes/CourbePolyLineaire1D.h index d0a03ae..0670f7a 100644 --- a/Util/Courbes/CourbePolyLineaire1D.h +++ b/Util/Courbes/CourbePolyLineaire1D.h @@ -152,13 +152,13 @@ class CourbePolyLineaire1D : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - virtual void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + virtual void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; // ------------ méthodes particulières à la fonction poly-linéaire --------- // ramène le nombre de point de la polyligne diff --git a/Util/Courbes/CourbePolyLineaire1D_simpli.cc b/Util/Courbes/CourbePolyLineaire1D_simpli.cc index 94a746c..0ee6281 100755 --- a/Util/Courbes/CourbePolyLineaire1D_simpli.cc +++ b/Util/Courbes/CourbePolyLineaire1D_simpli.cc @@ -164,7 +164,7 @@ void Cpl1D::Info_commande_Courbes1D(UtilLecture & entreePrinc) }; // sortie du schemaXML: en fonction de enu -void Cpl1D::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Cpl1D::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/CourbePolyLineaire1D_simpli.h b/Util/Courbes/CourbePolyLineaire1D_simpli.h index e910582..2fae18d 100644 --- a/Util/Courbes/CourbePolyLineaire1D_simpli.h +++ b/Util/Courbes/CourbePolyLineaire1D_simpli.h @@ -110,7 +110,7 @@ class Cpl1D : public CourbePolyLineaire1D // def info fichier de commande void Info_commande_Courbes1D(UtilLecture & entreePrinc); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; }; /// @} // end of group diff --git a/Util/Courbes/CourbePolynomiale.cc b/Util/Courbes/CourbePolynomiale.cc index a5149c5..e9228f6 100644 --- a/Util/Courbes/CourbePolynomiale.cc +++ b/Util/Courbes/CourbePolynomiale.cc @@ -249,7 +249,7 @@ Courbe1D::ValDerbool CourbePolynomiale::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void CourbePolynomiale::Lecture_base_info(ifstream& ent,const int cas) +void CourbePolynomiale::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -268,7 +268,7 @@ void CourbePolynomiale::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void CourbePolynomiale::Ecriture_base_info(ofstream& sort,const int cas) +void CourbePolynomiale::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " COURBEPOLYNOMIALE "; @@ -277,7 +277,7 @@ void CourbePolynomiale::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void CourbePolynomiale::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void CourbePolynomiale::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/CourbePolynomiale.h b/Util/Courbes/CourbePolynomiale.h index 65b7947..8cce540 100644 --- a/Util/Courbes/CourbePolynomiale.h +++ b/Util/Courbes/CourbePolynomiale.h @@ -142,13 +142,13 @@ class CourbePolynomiale : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/Courbe_cos.cc b/Util/Courbes/Courbe_cos.cc index a860358..8589462 100644 --- a/Util/Courbes/Courbe_cos.cc +++ b/Util/Courbes/Courbe_cos.cc @@ -274,7 +274,7 @@ Courbe1D::ValDerbool Courbe_cos::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_cos::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_cos::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -294,7 +294,7 @@ void Courbe_cos::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_cos::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_cos::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_cos "; @@ -305,7 +305,7 @@ void Courbe_cos::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Courbe_cos::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_cos::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_cos.h b/Util/Courbes/Courbe_cos.h index 8d7962c..6622c5e 100644 --- a/Util/Courbes/Courbe_cos.h +++ b/Util/Courbes/Courbe_cos.h @@ -144,13 +144,13 @@ class Courbe_cos : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Courbe_expo2_n.cc b/Util/Courbes/Courbe_expo2_n.cc index 7904e2b..57af451 100644 --- a/Util/Courbes/Courbe_expo2_n.cc +++ b/Util/Courbes/Courbe_expo2_n.cc @@ -197,7 +197,7 @@ Courbe1D::ValDerbool Courbe_expo2_n::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_expo2_n::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_expo2_n::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -216,7 +216,7 @@ void Courbe_expo2_n::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_expo2_n::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_expo2_n::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_expo2_n "; @@ -225,7 +225,7 @@ void Courbe_expo2_n::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Courbe_expo2_n::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_expo2_n::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_expo2_n.h b/Util/Courbes/Courbe_expo2_n.h index 7509bb4..b71ff8d 100644 --- a/Util/Courbes/Courbe_expo2_n.h +++ b/Util/Courbes/Courbe_expo2_n.h @@ -142,13 +142,13 @@ class Courbe_expo2_n : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Courbe_expo_n.cc b/Util/Courbes/Courbe_expo_n.cc index b3d0877..49dd33b 100644 --- a/Util/Courbes/Courbe_expo_n.cc +++ b/Util/Courbes/Courbe_expo_n.cc @@ -195,7 +195,7 @@ Courbe1D::ValDerbool Courbe_expo_n::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_expo_n::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_expo_n::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -214,7 +214,7 @@ void Courbe_expo_n::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_expo_n::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_expo_n::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_expo_n "; @@ -223,7 +223,7 @@ void Courbe_expo_n::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Courbe_expo_n::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_expo_n::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_expo_n.h b/Util/Courbes/Courbe_expo_n.h index c8763f9..49ed303 100644 --- a/Util/Courbes/Courbe_expo_n.h +++ b/Util/Courbes/Courbe_expo_n.h @@ -143,13 +143,13 @@ class Courbe_expo_n : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Courbe_expoaff.cc b/Util/Courbes/Courbe_expoaff.cc index e56c218..d818bd5 100755 --- a/Util/Courbes/Courbe_expoaff.cc +++ b/Util/Courbes/Courbe_expoaff.cc @@ -195,7 +195,7 @@ Courbe1D::ValDerbool Courbe_expoaff::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_expoaff::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_expoaff::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -214,7 +214,7 @@ void Courbe_expoaff::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_expoaff::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_expoaff::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_expoaff "; @@ -223,7 +223,7 @@ void Courbe_expoaff::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Courbe_expoaff::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_expoaff::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_expoaff.h b/Util/Courbes/Courbe_expoaff.h index d270e98..8c95807 100644 --- a/Util/Courbes/Courbe_expoaff.h +++ b/Util/Courbes/Courbe_expoaff.h @@ -143,13 +143,13 @@ class Courbe_expoaff : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/Courbe_expression_litterale_1D.cc b/Util/Courbes/Courbe_expression_litterale_1D.cc index 31ef04e..c1d4429 100755 --- a/Util/Courbes/Courbe_expression_litterale_1D.cc +++ b/Util/Courbes/Courbe_expression_litterale_1D.cc @@ -513,7 +513,7 @@ Courbe1D::ValDerbool Courbe_expression_litterale_1D::Valeur_Et_derivee_stricte( // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_expression_litterale_1D::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_expression_litterale_1D::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -534,7 +534,7 @@ void Courbe_expression_litterale_1D::Lecture_base_info(ifstream& ent,const int c // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_expression_litterale_1D::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_expression_litterale_1D::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_expression_litterale_1D "; @@ -545,7 +545,7 @@ void Courbe_expression_litterale_1D::Ecriture_base_info(ofstream& sort,const int }; // sortie du schemaXML: en fonction de enu -void Courbe_expression_litterale_1D::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_expression_litterale_1D::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_expression_litterale_1D.h b/Util/Courbes/Courbe_expression_litterale_1D.h index 330bd18..2711ec3 100755 --- a/Util/Courbes/Courbe_expression_litterale_1D.h +++ b/Util/Courbes/Courbe_expression_litterale_1D.h @@ -154,13 +154,13 @@ class Courbe_expression_litterale_1D : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.cc b/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.cc index 9f06a56..4c81832 100755 --- a/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.cc +++ b/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.cc @@ -480,7 +480,7 @@ Courbe1D::ValDerbool Courbe_expression_litterale_avec_derivees_1D::Valeur_Et_de // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_expression_litterale_avec_derivees_1D::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_expression_litterale_avec_derivees_1D::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -508,7 +508,7 @@ void Courbe_expression_litterale_avec_derivees_1D::Lecture_base_info(ifstream& e // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_expression_litterale_avec_derivees_1D::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_expression_litterale_avec_derivees_1D::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_expression_litterale_avec_derivees_1D "; @@ -521,7 +521,7 @@ void Courbe_expression_litterale_avec_derivees_1D::Ecriture_base_info(ofstream& }; // sortie du schemaXML: en fonction de enu -void Courbe_expression_litterale_avec_derivees_1D::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_expression_litterale_avec_derivees_1D::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.h b/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.h index 07af711..7ab8c88 100755 --- a/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.h +++ b/Util/Courbes/Courbe_expression_litterale_avec_derivees_1D.h @@ -149,13 +149,13 @@ class Courbe_expression_litterale_avec_derivees_1D : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Courbe_ln_cosh.cc b/Util/Courbes/Courbe_ln_cosh.cc index 331b252..3cf4914 100755 --- a/Util/Courbes/Courbe_ln_cosh.cc +++ b/Util/Courbes/Courbe_ln_cosh.cc @@ -574,7 +574,7 @@ Courbe1D::ValDerbool Courbe_ln_cosh::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_ln_cosh::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_ln_cosh::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -596,7 +596,7 @@ void Courbe_ln_cosh::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_ln_cosh::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_ln_cosh::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_ln_cosh "; @@ -609,7 +609,7 @@ void Courbe_ln_cosh::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Courbe_ln_cosh::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_ln_cosh::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_ln_cosh.h b/Util/Courbes/Courbe_ln_cosh.h index 765bffb..bf070cd 100755 --- a/Util/Courbes/Courbe_ln_cosh.h +++ b/Util/Courbes/Courbe_ln_cosh.h @@ -145,13 +145,13 @@ class Courbe_ln_cosh : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Courbe_relax_expo.cc b/Util/Courbes/Courbe_relax_expo.cc index 8457f76..a5a8afa 100644 --- a/Util/Courbes/Courbe_relax_expo.cc +++ b/Util/Courbes/Courbe_relax_expo.cc @@ -290,7 +290,7 @@ Courbe1D::ValDerbool Courbe_relax_expo::Valeur_Et_derivee_stricte(double X) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_relax_expo::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_relax_expo::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -309,7 +309,7 @@ void Courbe_relax_expo::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_relax_expo::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_relax_expo::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_relax_expo "; @@ -319,7 +319,7 @@ void Courbe_relax_expo::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Courbe_relax_expo::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_relax_expo::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_relax_expo.h b/Util/Courbes/Courbe_relax_expo.h index 27f15c6..f822488 100644 --- a/Util/Courbes/Courbe_relax_expo.h +++ b/Util/Courbes/Courbe_relax_expo.h @@ -144,13 +144,13 @@ class Courbe_relax_expo : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Courbe_sin.cc b/Util/Courbes/Courbe_sin.cc index f1eb3af..639fcce 100644 --- a/Util/Courbes/Courbe_sin.cc +++ b/Util/Courbes/Courbe_sin.cc @@ -274,7 +274,7 @@ Courbe1D::ValDerbool Courbe_sin::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_sin::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_sin::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -294,7 +294,7 @@ void Courbe_sin::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_sin::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_sin::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_sin "; @@ -305,7 +305,7 @@ void Courbe_sin::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Courbe_sin::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_sin::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_sin.h b/Util/Courbes/Courbe_sin.h index 05f716f..30714f0 100644 --- a/Util/Courbes/Courbe_sin.h +++ b/Util/Courbes/Courbe_sin.h @@ -145,13 +145,13 @@ class Courbe_sin : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Courbe_un_moins_cos.cc b/Util/Courbes/Courbe_un_moins_cos.cc index b3d0a47..ebb7cf7 100755 --- a/Util/Courbes/Courbe_un_moins_cos.cc +++ b/Util/Courbes/Courbe_un_moins_cos.cc @@ -225,7 +225,7 @@ Courbe1D::ValDerbool Courbe_un_moins_cos::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Courbe_un_moins_cos::Lecture_base_info(ifstream& ent,const int cas) +void Courbe_un_moins_cos::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -244,7 +244,7 @@ void Courbe_un_moins_cos::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Courbe_un_moins_cos::Ecriture_base_info(ofstream& sort,const int cas) +void Courbe_un_moins_cos::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " Courbe_un_moins_cos "; @@ -253,7 +253,7 @@ void Courbe_un_moins_cos::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Courbe_un_moins_cos::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void Courbe_un_moins_cos::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Courbe_un_moins_cos.h b/Util/Courbes/Courbe_un_moins_cos.h index 9cf328d..fdea41c 100644 --- a/Util/Courbes/Courbe_un_moins_cos.h +++ b/Util/Courbes/Courbe_un_moins_cos.h @@ -144,13 +144,13 @@ class Courbe_un_moins_cos : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/F1_plus_F2.cc b/Util/Courbes/F1_plus_F2.cc index 81f2b8b..ef5da80 100644 --- a/Util/Courbes/F1_plus_F2.cc +++ b/Util/Courbes/F1_plus_F2.cc @@ -426,7 +426,7 @@ Courbe1D::ValDerbool F1_plus_F2::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void F1_plus_F2::Lecture_base_info(ifstream& ent,const int cas) +void F1_plus_F2::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -496,7 +496,7 @@ void F1_plus_F2::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void F1_plus_F2::Ecriture_base_info(ofstream& sort,const int cas) +void F1_plus_F2::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " F1_PLUS_F2 "; @@ -522,7 +522,7 @@ void F1_plus_F2::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void F1_plus_F2::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void F1_plus_F2::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/F1_plus_F2.h b/Util/Courbes/F1_plus_F2.h index 92c4ba7..2453298 100644 --- a/Util/Courbes/F1_plus_F2.h +++ b/Util/Courbes/F1_plus_F2.h @@ -164,13 +164,13 @@ class F1_plus_F2 : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/F1_rond_F2.cc b/Util/Courbes/F1_rond_F2.cc index 4740187..e5f15e5 100644 --- a/Util/Courbes/F1_rond_F2.cc +++ b/Util/Courbes/F1_rond_F2.cc @@ -400,7 +400,7 @@ Courbe1D::ValDerbool F1_rond_F2::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void F1_rond_F2::Lecture_base_info(ifstream& ent,const int cas) +void F1_rond_F2::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -469,7 +469,7 @@ void F1_rond_F2::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void F1_rond_F2::Ecriture_base_info(ofstream& sort,const int cas) +void F1_rond_F2::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " F1_ROND_F2 "; @@ -493,7 +493,7 @@ void F1_rond_F2::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void F1_rond_F2::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void F1_rond_F2::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/F1_rond_F2.h b/Util/Courbes/F1_rond_F2.h index cbef30c..86e01ab 100644 --- a/Util/Courbes/F1_rond_F2.h +++ b/Util/Courbes/F1_rond_F2.h @@ -163,13 +163,13 @@ class F1_rond_F2 : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/F_cycle_add.cc b/Util/Courbes/F_cycle_add.cc index 399efdf..30850ca 100644 --- a/Util/Courbes/F_cycle_add.cc +++ b/Util/Courbes/F_cycle_add.cc @@ -403,7 +403,7 @@ Courbe1D::ValDerbool F_cycle_add::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void F_cycle_add::Lecture_base_info(ifstream& ent,const int cas) +void F_cycle_add::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -474,7 +474,7 @@ void F_cycle_add::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void F_cycle_add::Ecriture_base_info(ofstream& sort,const int cas) +void F_cycle_add::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " F_CYCLE_ADD "; @@ -495,8 +495,8 @@ void F_cycle_add::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -//void F_cycle_add::SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) -void F_cycle_add::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +//void F_cycle_add::SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) +void F_cycle_add::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/F_cycle_add.h b/Util/Courbes/F_cycle_add.h index 07fbe17..c6ada4b 100644 --- a/Util/Courbes/F_cycle_add.h +++ b/Util/Courbes/F_cycle_add.h @@ -167,13 +167,13 @@ class F_cycle_add : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/F_cyclique.cc b/Util/Courbes/F_cyclique.cc index c3bef9a..3a1a815 100644 --- a/Util/Courbes/F_cyclique.cc +++ b/Util/Courbes/F_cyclique.cc @@ -434,7 +434,7 @@ Courbe1D::ValDerbool F_cyclique::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void F_cyclique::Lecture_base_info(ifstream& ent,const int cas) +void F_cyclique::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -505,7 +505,7 @@ void F_cyclique::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void F_cyclique::Ecriture_base_info(ofstream& sort,const int cas) +void F_cyclique::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " F_CYCLIQUE "; @@ -526,8 +526,8 @@ void F_cyclique::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -//void F_cyclique::SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) -void F_cyclique::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +//void F_cyclique::SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) +void F_cyclique::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/F_cyclique.h b/Util/Courbes/F_cyclique.h index 8ab4b23..f93cdc5 100644 --- a/Util/Courbes/F_cyclique.h +++ b/Util/Courbes/F_cyclique.h @@ -168,13 +168,13 @@ class F_cyclique : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/F_nD_courbe1D.cc b/Util/Courbes/F_nD_courbe1D.cc index e167e7c..f9cbe7c 100755 --- a/Util/Courbes/F_nD_courbe1D.cc +++ b/Util/Courbes/F_nD_courbe1D.cc @@ -326,7 +326,7 @@ void F_nD_courbe1D::Lien_entre_fonc_courbe (list & ,list & F_nD_courbe1D::Valeur_pour_variables_globales_interne() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void F_nD_courbe1D::Lecture_base_info(ifstream& ent,const int cas) +void F_nD_courbe1D::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -1083,7 +1083,7 @@ void F_nD_courbe1D::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void F_nD_courbe1D::Ecriture_base_info(ofstream& sort,const int cas) +void F_nD_courbe1D::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << "\n "; @@ -1112,7 +1112,7 @@ void F_nD_courbe1D::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void F_nD_courbe1D::SchemaXML_Fonctions_nD(ofstream& ,const Enum_IO_XML enu) +void F_nD_courbe1D::SchemaXML_Fonctions_nD(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/F_nD_courbe1D.h b/Util/Courbes/F_nD_courbe1D.h index 1447b50..5ab9c21 100755 --- a/Util/Courbes/F_nD_courbe1D.h +++ b/Util/Courbes/F_nD_courbe1D.h @@ -151,13 +151,13 @@ class F_nD_courbe1D : public Fonction_nD // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/F_union_1D.cc b/Util/Courbes/F_union_1D.cc index 46e8845..b0b8c6b 100644 --- a/Util/Courbes/F_union_1D.cc +++ b/Util/Courbes/F_union_1D.cc @@ -667,7 +667,7 @@ Courbe1D::ValDerbool F_union_1D::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void F_union_1D::Lecture_base_info(ifstream& ent,const int cas) +void F_union_1D::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -730,7 +730,7 @@ void F_union_1D::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void F_union_1D::Ecriture_base_info(ofstream& sort,const int cas) +void F_union_1D::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << "\n "; @@ -758,7 +758,7 @@ void F_union_1D::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void F_union_1D::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void F_union_1D::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/F_union_1D.h b/Util/Courbes/F_union_1D.h index 60f8cfb..07cba90 100644 --- a/Util/Courbes/F_union_1D.h +++ b/Util/Courbes/F_union_1D.h @@ -153,13 +153,13 @@ class F_union_1D : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/Fonc_scal_combinees_nD.cc b/Util/Courbes/Fonc_scal_combinees_nD.cc index db9d9b7..2ebfb8f 100755 --- a/Util/Courbes/Fonc_scal_combinees_nD.cc +++ b/Util/Courbes/Fonc_scal_combinees_nD.cc @@ -1679,7 +1679,7 @@ list & Fonc_scal_combinees_nD::ListDependanceCourbes(list & lico // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Fonc_scal_combinees_nD::Lecture_base_info(ifstream& ent,const int cas) +void Fonc_scal_combinees_nD::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -1763,7 +1763,7 @@ void Fonc_scal_combinees_nD::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Fonc_scal_combinees_nD::Ecriture_base_info(ofstream& sort,const int cas) +void Fonc_scal_combinees_nD::Ecriture_base_info(ostream& sort,const int cas) { if (cas == 1) { sort << "\n " @@ -1801,7 +1801,7 @@ void Fonc_scal_combinees_nD::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Fonc_scal_combinees_nD::SchemaXML_Fonctions_nD(ofstream& ,const Enum_IO_XML enu) +void Fonc_scal_combinees_nD::SchemaXML_Fonctions_nD(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Fonc_scal_combinees_nD.h b/Util/Courbes/Fonc_scal_combinees_nD.h index 22533d8..f18bdbc 100755 --- a/Util/Courbes/Fonc_scal_combinees_nD.h +++ b/Util/Courbes/Fonc_scal_combinees_nD.h @@ -148,13 +148,13 @@ class Fonc_scal_combinees_nD : public Fonction_nD // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); protected : diff --git a/Util/Courbes/Fonction_expression_litterale_nD.cc b/Util/Courbes/Fonction_expression_litterale_nD.cc index 4d411e8..ddde9b5 100755 --- a/Util/Courbes/Fonction_expression_litterale_nD.cc +++ b/Util/Courbes/Fonction_expression_litterale_nD.cc @@ -648,7 +648,7 @@ Tableau & Fonction_expression_litterale_nD::Valeur_pour_variables_globa // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Fonction_expression_litterale_nD::Lecture_base_info(ifstream& ent,const int cas) +void Fonction_expression_litterale_nD::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -684,7 +684,7 @@ void Fonction_expression_litterale_nD::Lecture_base_info(ifstream& ent,const int // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Fonction_expression_litterale_nD::Ecriture_base_info(ofstream& sort,const int cas) +void Fonction_expression_litterale_nD::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << "\n "; @@ -700,7 +700,7 @@ void Fonction_expression_litterale_nD::Ecriture_base_info(ofstream& sort,const i }; // sortie du schemaXML: en fonction de enu -void Fonction_expression_litterale_nD::SchemaXML_Fonctions_nD(ofstream& ,const Enum_IO_XML enu) +void Fonction_expression_litterale_nD::SchemaXML_Fonctions_nD(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Fonction_expression_litterale_nD.h b/Util/Courbes/Fonction_expression_litterale_nD.h index 7c089d5..081a086 100755 --- a/Util/Courbes/Fonction_expression_litterale_nD.h +++ b/Util/Courbes/Fonction_expression_litterale_nD.h @@ -143,13 +143,13 @@ class Fonction_expression_litterale_nD : public Fonction_nD // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - virtual void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + virtual void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Fonction_externe_nD.cc b/Util/Courbes/Fonction_externe_nD.cc index 4655ee9..fb4b327 100755 --- a/Util/Courbes/Fonction_externe_nD.cc +++ b/Util/Courbes/Fonction_externe_nD.cc @@ -1166,7 +1166,7 @@ Tableau & Fonction_externe_nD::Valeur_pour_variables_globales_interne() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Fonction_externe_nD::Lecture_base_info(ifstream& ent,const int cas) +void Fonction_externe_nD::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -1214,7 +1214,7 @@ void Fonction_externe_nD::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Fonction_externe_nD::Ecriture_base_info(ofstream& sort,const int cas) +void Fonction_externe_nD::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << "\n "; @@ -1229,7 +1229,7 @@ void Fonction_externe_nD::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Fonction_externe_nD::SchemaXML_Fonctions_nD(ofstream& ,const Enum_IO_XML enu) +void Fonction_externe_nD::SchemaXML_Fonctions_nD(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Fonction_externe_nD.h b/Util/Courbes/Fonction_externe_nD.h index af04742..86b485f 100755 --- a/Util/Courbes/Fonction_externe_nD.h +++ b/Util/Courbes/Fonction_externe_nD.h @@ -148,13 +148,13 @@ class Fonction_externe_nD : public Fonction_nD // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - virtual void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + virtual void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); protected : // VARIABLES PROTEGEES : diff --git a/Util/Courbes/Fonction_nD.cc b/Util/Courbes/Fonction_nD.cc index a7dd27f..bf5e69b 100755 --- a/Util/Courbes/Fonction_nD.cc +++ b/Util/Courbes/Fonction_nD.cc @@ -1528,7 +1528,7 @@ void Fonction_nD::Affiche_interne(int niveau) const // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Fonction_nD::Lect_base_info(ifstream& ent,const int cas) +void Fonction_nD::Lect_base_info(istream& ent,const int cas) { if (cas == 1) { string toto; string nom; @@ -1586,7 +1586,7 @@ void Fonction_nD::Lect_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Fonction_nD::Ecrit_base_info(ofstream& sort,const int cas) +void Fonction_nD::Ecrit_base_info(ostream& sort,const int cas) { if (cas == 1) { // les variables @@ -1627,7 +1627,7 @@ void Fonction_nD::Ecrit_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Fonction_nD::SchemXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu) +void Fonction_nD::SchemXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Fonction_nD.h b/Util/Courbes/Fonction_nD.h index 25600e2..d4c7bc4 100755 --- a/Util/Courbes/Fonction_nD.h +++ b/Util/Courbes/Fonction_nD.h @@ -490,13 +490,13 @@ class Fonction_nD // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info(ifstream& ent,const int cas) = 0; + virtual void Lecture_base_info(istream& ent,const int cas) = 0; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas) = 0; + virtual void Ecriture_base_info(ostream& sort,const int cas) = 0; // sortie du schemaXML: en fonction de enu - virtual void SchemaXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu) = 0; + virtual void SchemaXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu) = 0; // ---------- static --------- @@ -723,13 +723,13 @@ class Fonction_nD // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lect_base_info(ifstream& ent,const int cas); + void Lect_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecrit_base_info(ofstream& sort,const int cas); + void Ecrit_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu); + void SchemXML_Fonctions_nD(ostream& sort,const Enum_IO_XML enu); // lecture d'une ou plusieurs variables // peut-être appelée plusieurs fois, diff --git a/Util/Courbes/LesCourbes1D.cc b/Util/Courbes/LesCourbes1D.cc index 50c4d02..c396ef4 100755 --- a/Util/Courbes/LesCourbes1D.cc +++ b/Util/Courbes/LesCourbes1D.cc @@ -303,7 +303,7 @@ bool LesCourbes1D::Complet() // on crée une nouvelle courbe adoc, on lie avec Lecture_base_info, et on ramène // un pointeur sur la courbe ainsi crée -Courbe1D * LesCourbes1D::Lecture_pour_base_info(ifstream& ent,const int cas,Courbe1D * ptcourbe) +Courbe1D * LesCourbes1D::Lecture_pour_base_info(istream& ent,const int cas,Courbe1D * ptcourbe) { EnumCourbe1D type_de_courbe;string nom_courbe; ent >> nom_courbe >> type_de_courbe; if (ptcourbe == NULL) @@ -363,7 +363,7 @@ Courbe1D * LesCourbes1D::Lecture_pour_base_info(ifstream& ent,const int cas,Cour // écriture pour base info // c'est le pendant de Lecture_pour_base_info, de manière à être cohérent -void LesCourbes1D::Ecriture_pour_base_info(ofstream& sort,const int cas,Courbe1D * ptcourbe) +void LesCourbes1D::Ecriture_pour_base_info(ostream& sort,const int cas,Courbe1D * ptcourbe) { // la courbe d'écrouissage sort << ptcourbe->NomCourbe() << " " << ptcourbe->Type_courbe() << " "; // écriture le la courbe elle-même que si le nom est "_" @@ -376,7 +376,7 @@ void LesCourbes1D::Ecriture_pour_base_info(ofstream& sort,const int cas,Courbe1D // lecture base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesCourbes1D::Lecture_base_info(ifstream& entr,const int cas) +void LesCourbes1D::Lecture_base_info(istream& entr,const int cas) {if (cas == 1) {cout << " == lecture des courbes \n"; string toto;int taille; entr >> toto >> taille ; // passage de l'entête @@ -412,7 +412,7 @@ void LesCourbes1D::Lecture_base_info(ifstream& entr,const int cas) // écriture base info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesCourbes1D::Ecriture_base_info(ofstream& sort,const int cas) +void LesCourbes1D::Ecriture_base_info(ostream& sort,const int cas) { if (cas == 1) {sort << "\n \n****les_courbes1D_:_nombre= " << listeDeCourbe1D.size() ; @@ -431,7 +431,7 @@ void LesCourbes1D::Ecriture_base_info(ofstream& sort,const int cas) // sortie du schemaXML: en fonction de enu -void LesCourbes1D::SchemaXML_lesCourbes1D(ofstream& sort,const Enum_IO_XML enu) +void LesCourbes1D::SchemaXML_lesCourbes1D(ostream& sort,const Enum_IO_XML enu) { switch (enu) {case XML_TYPE_GLOBAUX: // cas du premier passage {// cas des classes de base, on commence par créé la liste globale des courbes possible diff --git a/Util/Courbes/LesCourbes1D.h b/Util/Courbes/LesCourbes1D.h index 6354cee..1f52c77 100644 --- a/Util/Courbes/LesCourbes1D.h +++ b/Util/Courbes/LesCourbes1D.h @@ -137,23 +137,23 @@ class LesCourbes1D // on crée une nouvelle courbe adoc, on lie avec Lecture_base_info, et on ramène // un pointeur sur la courbe ainsi crée - Courbe1D * Lecture_pour_base_info(ifstream& ent,const int cas,Courbe1D * ptcourbe); + Courbe1D * Lecture_pour_base_info(istream& ent,const int cas,Courbe1D * ptcourbe); // écriture pour base info // c'est le pendant de Lecture_pour_base_info, de manière à être cohérent - static void Ecriture_pour_base_info(ofstream& sort,const int cas,Courbe1D * ptcourbe); + static void Ecriture_pour_base_info(ostream& sort,const int cas,Courbe1D * ptcourbe); //----- lecture écriture dans base info ----- // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_lesCourbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_lesCourbes1D(ostream& sort,const Enum_IO_XML enu) ; protected : diff --git a/Util/Courbes/LesFonctions_nD.cc b/Util/Courbes/LesFonctions_nD.cc index 428b898..8394a74 100644 --- a/Util/Courbes/LesFonctions_nD.cc +++ b/Util/Courbes/LesFonctions_nD.cc @@ -371,7 +371,7 @@ bool LesFonctions_nD::Complet() // on crée une nouvelle fonction adoc, on lie avec Lecture_base_info, et on ramène // un pointeur sur la fonction ainsi crée -Fonction_nD * LesFonctions_nD::Lecture_pour_base_info(ifstream& ent,const int cas,Fonction_nD * ptfonction) +Fonction_nD * LesFonctions_nD::Lecture_pour_base_info(istream& ent,const int cas,Fonction_nD * ptfonction) { EnumFonction_nD type_de_fonction;string nom_fonction; ent >> nom_fonction >> type_de_fonction; if (ptfonction == NULL) @@ -431,7 +431,7 @@ Fonction_nD * LesFonctions_nD::Lecture_pour_base_info(ifstream& ent,const int ca // écriture pour base info // c'est le pendant de Lecture_pour_base_info, de manière à être cohérent -void LesFonctions_nD::Ecriture_pour_base_info(ofstream& sort,const int cas,Fonction_nD * ptfonction) +void LesFonctions_nD::Ecriture_pour_base_info(ostream& sort,const int cas,Fonction_nD * ptfonction) { // la fonction sort << ptfonction->NomFonction() << " " << ptfonction->Type_Fonction() << " "; // écriture le la fonction elle-même que si le nom est "_" @@ -444,7 +444,7 @@ void LesFonctions_nD::Ecriture_pour_base_info(ofstream& sort,const int cas,Fonct // lecture base info // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesFonctions_nD::Lecture_base_info(ifstream& entr,const int cas) +void LesFonctions_nD::Lecture_base_info(istream& entr,const int cas) {if (cas == 1) {cout << " == lecture des fonctions \n"; string toto;int taille; entr >> toto >> taille ; // passage de l'entête @@ -515,7 +515,7 @@ void LesFonctions_nD::Lecture_base_info(ifstream& entr,const int cas) // écriture base info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesFonctions_nD::Ecriture_base_info(ofstream& sort,const int cas) +void LesFonctions_nD::Ecriture_base_info(ostream& sort,const int cas) { if (cas == 1) {sort << "\n \n****les_fonctions_nD_:_nombre= " << listeDeFonction_nD.size() ; @@ -534,7 +534,7 @@ void LesFonctions_nD::Ecriture_base_info(ofstream& sort,const int cas) // sortie du schemaXML: en fonction de enu -void LesFonctions_nD::SchemaXML_lesFonctions_nD(ofstream& sort,const Enum_IO_XML enu) +void LesFonctions_nD::SchemaXML_lesFonctions_nD(ostream& sort,const Enum_IO_XML enu) { switch (enu) {case XML_TYPE_GLOBAUX: // cas du premier passage {// cas des classes de base, on commence par créé la liste globale des fonctions possible diff --git a/Util/Courbes/LesFonctions_nD.h b/Util/Courbes/LesFonctions_nD.h index b229ef9..7bd7314 100755 --- a/Util/Courbes/LesFonctions_nD.h +++ b/Util/Courbes/LesFonctions_nD.h @@ -140,23 +140,23 @@ class LesFonctions_nD // on crée une nouvelle courbe adoc, on lie avec Lecture_base_info, et on ramène // un pointeur sur la courbe ainsi crée - Fonction_nD * Lecture_pour_base_info(ifstream& ent,const int cas,Fonction_nD * ptcourbe); + Fonction_nD * Lecture_pour_base_info(istream& ent,const int cas,Fonction_nD * ptcourbe); // écriture pour base info // c'est le pendant de Lecture_pour_base_info, de manière à être cohérent - static void Ecriture_pour_base_info(ofstream& sort,const int cas,Fonction_nD * ptcourbe); + static void Ecriture_pour_base_info(ostream& sort,const int cas,Fonction_nD * ptcourbe); //----- lecture écriture dans base info ----- // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_lesFonctions_nD(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_lesFonctions_nD(ostream& sort,const Enum_IO_XML enu) ; protected : diff --git a/Util/Courbes/Poly_Lagrange.cc b/Util/Courbes/Poly_Lagrange.cc index e1c85ec..75130e9 100644 --- a/Util/Courbes/Poly_Lagrange.cc +++ b/Util/Courbes/Poly_Lagrange.cc @@ -525,7 +525,7 @@ void Poly_Lagrange::Change_tabPoints(Tableau & pt) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Poly_Lagrange::Lecture_base_info(ifstream& ent,const int cas) +void Poly_Lagrange::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -551,7 +551,7 @@ void Poly_Lagrange::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Poly_Lagrange::Ecriture_base_info(ofstream& sort,const int cas) +void Poly_Lagrange::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << "\n " @@ -563,7 +563,7 @@ void Poly_Lagrange::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void Poly_Lagrange::SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) +void Poly_Lagrange::SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/Poly_Lagrange.h b/Util/Courbes/Poly_Lagrange.h index 1de7b6e..ffad8ba 100644 --- a/Util/Courbes/Poly_Lagrange.h +++ b/Util/Courbes/Poly_Lagrange.h @@ -150,13 +150,13 @@ class Poly_Lagrange : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - virtual void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + virtual void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; // ------------ méthodes particulières à la fonction poly-linéaire --------- // ramène le nombre de point de la polyligne diff --git a/Util/Courbes/SixpodeCos3phi.cc b/Util/Courbes/SixpodeCos3phi.cc index 1d09d56..695e22c 100644 --- a/Util/Courbes/SixpodeCos3phi.cc +++ b/Util/Courbes/SixpodeCos3phi.cc @@ -192,7 +192,7 @@ Courbe1D::ValDerbool SixpodeCos3phi::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void SixpodeCos3phi::Lecture_base_info(ifstream& ent,const int cas) +void SixpodeCos3phi::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -211,7 +211,7 @@ void SixpodeCos3phi::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void SixpodeCos3phi::Ecriture_base_info(ofstream& sort,const int cas) +void SixpodeCos3phi::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " SixpodeCos3phi "; @@ -220,7 +220,7 @@ void SixpodeCos3phi::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void SixpodeCos3phi::SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) +void SixpodeCos3phi::SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/Util/Courbes/SixpodeCos3phi.h b/Util/Courbes/SixpodeCos3phi.h index 2531104..27c9912 100644 --- a/Util/Courbes/SixpodeCos3phi.h +++ b/Util/Courbes/SixpodeCos3phi.h @@ -143,13 +143,13 @@ class SixpodeCos3phi : public Courbe1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // sortie du schemaXML: en fonction de enu - void SchemaXML_Courbes1D(ofstream& sort,const Enum_IO_XML enu) ; + void SchemaXML_Courbes1D(ostream& sort,const Enum_IO_XML enu) ; diff --git a/Util/Courbes/TangenteHyperbolique.cc b/Util/Courbes/TangenteHyperbolique.cc index 06dfbf2..5383a07 100644 --- a/Util/Courbes/TangenteHyperbolique.cc +++ b/Util/Courbes/TangenteHyperbolique.cc @@ -215,7 +215,7 @@ Courbe1D::ValDerbool TangenteHyperbolique::Valeur_Et_derivee_stricte(double x) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void TangenteHyperbolique::Lecture_base_info(ifstream& ent,const int cas) +void TangenteHyperbolique::Lecture_base_info(istream& ent,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { string nom; @@ -234,7 +234,7 @@ void TangenteHyperbolique::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void TangenteHyperbolique::Ecriture_base_info(ofstream& sort,const int cas) +void TangenteHyperbolique::Ecriture_base_info(ostream& sort,const int cas) { // on n'a que des grandeurs constantes if (cas == 1) { sort << " TangenteHyperbolique "; @@ -243,7 +243,7 @@ void TangenteHyperbolique::Ecriture_base_info(ofstream& sort,const int cas) }; // sortie du schemaXML: en fonction de enu -void TangenteHyperbolique::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) +void TangenteHyperbolique::SchemaXML_Courbes1D(ostream& ,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : @@ -264,7 +264,7 @@ void TangenteHyperbolique::SchemaXML_Courbes1D(ofstream& ,const Enum_IO_XML enu) } default: cout << "\n *** attention cas non pris en compte pour le moment " << " XML_TYPE_GLOBAUX= "<> toto >> presence; #ifdef MISE_AU_POINT @@ -156,7 +156,7 @@ void HyperD::SaveResulHyperD::Lecture_base_info (ifstream& ent,const int ) // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void HyperD::SaveResulHyperD::Ecriture_base_info(ofstream& sort,const int ) +void HyperD::SaveResulHyperD::Ecriture_base_info(ostream& sort,const int ) { sort << "\n dat_sp_hyperelas: "; if (invP != NULL) { sort << " 1 " << (*invP); }// V= " << invP->V << " Qeps= "<< invP->Qeps << " cos3phi= "<< invP->cos3phi << " "; }// V,Qeps,cos3phi; diff --git a/comportement/Hyper_elastique/HyperD.h b/comportement/Hyper_elastique/HyperD.h index cddd9ec..aed3d2e 100644 --- a/comportement/Hyper_elastique/HyperD.h +++ b/comportement/Hyper_elastique/HyperD.h @@ -142,11 +142,11 @@ class HyperD : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info (ifstream& ,const int ) ; + virtual void Lecture_base_info (istream& ,const int ) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& ,const int ) ; + virtual void Ecriture_base_info(ostream& ,const int ) ; // mise à jour des informations transitoires virtual void TdtversT() ; @@ -219,11 +219,11 @@ class HyperD : public Loi_comp_abstraite // // cas donne le niveau de la récupération // // = 1 : on récupère tout // // = 2 : on récupère uniquement les données variables (supposées comme telles) -// virtual void Lecture_base_info (ifstream& ,const int ) {}; +// virtual void Lecture_base_info (istream& ,const int ) {}; // // cas donne le niveau de sauvegarde // // = 1 : on sauvegarde tout // // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -// virtual void Ecriture_base_info(ofstream& ,const int ) {}; +// virtual void Ecriture_base_info(ostream& ,const int ) {}; // // // affichage à l'écran des infos // void Affiche() const { cout << "\n SaveResulHyperD: jacobien_0= " << jacobien_0 << " "; }; @@ -238,7 +238,7 @@ class HyperD : public Loi_comp_abstraite // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) - void AfficheDataSpecif(ofstream& ,SaveResul * ) const {}; + void AfficheDataSpecif(ostream& ,SaveResul * ) const {}; // activation du stockage de grandeurs quelconques qui pourront ensuite être récupéré // via le conteneur SaveResul, si la grandeur n'existe pas ici, aucune action diff --git a/comportement/Hyper_elastique/HyperDN.h b/comportement/Hyper_elastique/HyperDN.h index db57f3a..143b732 100644 --- a/comportement/Hyper_elastique/HyperDN.h +++ b/comportement/Hyper_elastique/HyperDN.h @@ -109,11 +109,11 @@ class HyperDN : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info (ifstream& ent,const int cas) {}; + virtual void Lecture_base_info (istream& ent,const int cas) {}; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas) {}; + virtual void Ecriture_base_info(ostream& sort,const int cas) {}; // affichage à l'écran des infos void Affiche() const { cout << "\n SaveResulHyperDN: jacobien_0= " << jacobien_0 << " ";}; @@ -143,7 +143,7 @@ class HyperDN : public Loi_comp_abstraite // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) - void AfficheDataSpecif(ofstream& ,SaveResul * ) const {}; + void AfficheDataSpecif(ostream& ,SaveResul * ) const {}; protected : diff --git a/comportement/Hyper_elastique/Hyper_W_gene_3D.cc b/comportement/Hyper_elastique/Hyper_W_gene_3D.cc index 9309a50..76d4da9 100644 --- a/comportement/Hyper_elastique/Hyper_W_gene_3D.cc +++ b/comportement/Hyper_elastique/Hyper_W_gene_3D.cc @@ -138,7 +138,7 @@ Loi_comp_abstraite::SaveResul & Hyper_W_gene_3D::SaveResulHyper_W_gene_3D::opera // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hyper_W_gene_3D::SaveResulHyper_W_gene_3D::Lecture_base_info (ifstream& ent,const int ) +void Hyper_W_gene_3D::SaveResulHyper_W_gene_3D::Lecture_base_info (istream& ent,const int ) { string toto; int presence=0; ent >> toto >> presence; #ifdef MISE_AU_POINT @@ -189,7 +189,7 @@ void Hyper_W_gene_3D::SaveResulHyper_W_gene_3D::Lecture_base_info (ifstream& ent // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Hyper_W_gene_3D::SaveResulHyper_W_gene_3D::Ecriture_base_info(ofstream& sort,const int ) +void Hyper_W_gene_3D::SaveResulHyper_W_gene_3D::Ecriture_base_info(ostream& sort,const int ) { sort << "\n dat_sp_hyperelas: "; if (invP != NULL) { sort << " 1 " << (*invP); } diff --git a/comportement/Hyper_elastique/Hyper_W_gene_3D.h b/comportement/Hyper_elastique/Hyper_W_gene_3D.h index 6759f38..49a501a 100644 --- a/comportement/Hyper_elastique/Hyper_W_gene_3D.h +++ b/comportement/Hyper_elastique/Hyper_W_gene_3D.h @@ -143,11 +143,11 @@ class Hyper_W_gene_3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info (ifstream& ,const int ) ; + virtual void Lecture_base_info (istream& ,const int ) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& ,const int ) ; + virtual void Ecriture_base_info(ostream& ,const int ) ; // mise à jour des informations transitoires void TdtversT() ; diff --git a/comportement/Hyper_elastique/Hyper_externe_W.cc b/comportement/Hyper_elastique/Hyper_externe_W.cc index 9a5aef8..8311b27 100755 --- a/comportement/Hyper_elastique/Hyper_externe_W.cc +++ b/comportement/Hyper_elastique/Hyper_externe_W.cc @@ -147,7 +147,7 @@ Loi_comp_abstraite::SaveResul & Hyper_externe_W::SaveResulHyper_externe_W::oper // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hyper_externe_W::SaveResulHyper_externe_W::Lecture_base_info (ifstream& ent,const int cas) +void Hyper_externe_W::SaveResulHyper_externe_W::Lecture_base_info (istream& ent,const int cas) { // entête via la classe mère Hyper_W_gene_3D::SaveResulHyper_W_gene_3D::Lecture_base_info(ent,cas); // puis les données spécifiques @@ -190,7 +190,7 @@ void Hyper_externe_W::SaveResulHyper_externe_W::Lecture_base_info (ifstream& ent // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Hyper_externe_W::SaveResulHyper_externe_W::Ecriture_base_info(ofstream& sort,const int cas) +void Hyper_externe_W::SaveResulHyper_externe_W::Ecriture_base_info(ostream& sort,const int cas) { // entête via la classe mère Hyper_W_gene_3D::SaveResulHyper_W_gene_3D::Ecriture_base_info(sort,cas); // puis les données spécifiques @@ -482,7 +482,7 @@ int Hyper_externe_W::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hyper_externe_W::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Hyper_externe_W::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; bool test; if (cas == 1) @@ -518,7 +518,7 @@ void Hyper_externe_W::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefer // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Hyper_externe_W::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Hyper_externe_W::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " HYPER_EXTERNE_W sortie_post_ "<< sortie_post ; if (W_potentiel != NULL) diff --git a/comportement/Hyper_elastique/Hyper_externe_W.h b/comportement/Hyper_elastique/Hyper_externe_W.h index 535d01b..c61c28d 100755 --- a/comportement/Hyper_elastique/Hyper_externe_W.h +++ b/comportement/Hyper_elastique/Hyper_externe_W.h @@ -119,12 +119,12 @@ class SaveResulHyper_externe_W: public SaveResulHyper_W_gene_3D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires void TdtversT(); @@ -168,7 +168,7 @@ class SaveResulHyper_externe_W: public SaveResulHyper_W_gene_3D // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) - void AfficheDataSpecif(ofstream& ,SaveResul * a) const + void AfficheDataSpecif(ostream& ,SaveResul * a) const { SaveResulHyper_externe_W& sav = *((SaveResulHyper_externe_W*) a); sav.Affiche(); }; @@ -186,12 +186,12 @@ class SaveResulHyper_externe_W: public SaveResulHyper_W_gene_3D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // récupération des grandeurs particulière (hors ddl ) // correspondant à liTQ diff --git a/comportement/Hyper_elastique/IsoHyper3DFavier3.cc b/comportement/Hyper_elastique/IsoHyper3DFavier3.cc index ee9ee9e..a393534 100644 --- a/comportement/Hyper_elastique/IsoHyper3DFavier3.cc +++ b/comportement/Hyper_elastique/IsoHyper3DFavier3.cc @@ -90,7 +90,7 @@ Loi_comp_abstraite::SaveResul & IsoHyper3DFavier3::SaveResulIsoHyper3DFavier3 // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void IsoHyper3DFavier3::SaveResulIsoHyper3DFavier3::Lecture_base_info (ifstream& ent,const int cas) +void IsoHyper3DFavier3::SaveResulIsoHyper3DFavier3::Lecture_base_info (istream& ent,const int cas) {SaveResulHyperD::Lecture_base_info (ent,cas); string toto; ent >> toto; @@ -112,7 +112,7 @@ void IsoHyper3DFavier3::SaveResulIsoHyper3DFavier3::Lecture_base_info (ifstream& // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void IsoHyper3DFavier3::SaveResulIsoHyper3DFavier3::Ecriture_base_info(ofstream& sort,const int cas) +void IsoHyper3DFavier3::SaveResulIsoHyper3DFavier3::Ecriture_base_info(ostream& sort,const int cas) {SaveResulHyperD::Ecriture_base_info (sort,cas); if (para_loi == NULL) {sort << " sans_para ";} @@ -640,7 +640,7 @@ int IsoHyper3DFavier3::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void IsoHyper3DFavier3::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef +void IsoHyper3DFavier3::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef ,LesCourbes1D& lesCourbe1D,LesFonctions_nD& lesFonctionsnD) { string toto,nom; if (cas == 1) @@ -795,7 +795,7 @@ void IsoHyper3DFavier3::Lecture_base_info_loi(ifstream& ent,const int cas,LesRef // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void IsoHyper3DFavier3::Ecriture_base_info_loi(ofstream& sort,const int cas) +void IsoHyper3DFavier3::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " ISOHYPER3DFAVIER3,thermodependance= " << thermo_dependant ; sort << " module_K "; diff --git a/comportement/Hyper_elastique/IsoHyper3DFavier3.h b/comportement/Hyper_elastique/IsoHyper3DFavier3.h index 53863b8..0c53305 100644 --- a/comportement/Hyper_elastique/IsoHyper3DFavier3.h +++ b/comportement/Hyper_elastique/IsoHyper3DFavier3.h @@ -100,11 +100,11 @@ class IsoHyper3DFavier3 : public Hyper3D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info (ifstream& ent,const int cas); + virtual void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas); + virtual void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires virtual void TdtversT(); @@ -176,12 +176,12 @@ class IsoHyper3DFavier3 : public Hyper3D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // récupération des grandeurs particulière (hors ddl ) // correspondant à liTQ diff --git a/comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc b/comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc index 6984323..ef89ed5 100644 --- a/comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc +++ b/comportement/Hyper_elastique/IsoHyper3DOrgeas1.cc @@ -622,7 +622,7 @@ int IsoHyper3DOrgeas1::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void IsoHyper3DOrgeas1::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void IsoHyper3DOrgeas1::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -732,7 +732,7 @@ void IsoHyper3DOrgeas1::Lecture_base_info_loi(ifstream& ent,const int cas,LesRef // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void IsoHyper3DOrgeas1::Ecriture_base_info_loi(ofstream& sort,const int cas) +void IsoHyper3DOrgeas1::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " module_dilatation " << K << " cas_Q0s_thermo_dependant " << cas_Q0s_thermo_dependant; if (cas_Q0s_thermo_dependant != 0) diff --git a/comportement/Hyper_elastique/IsoHyper3DOrgeas1.h b/comportement/Hyper_elastique/IsoHyper3DOrgeas1.h index 6c911ac..d763fd9 100644 --- a/comportement/Hyper_elastique/IsoHyper3DOrgeas1.h +++ b/comportement/Hyper_elastique/IsoHyper3DOrgeas1.h @@ -92,12 +92,12 @@ class IsoHyper3DOrgeas1 : public Hyper3D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc b/comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc index 4903237..3f4c12f 100644 --- a/comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc +++ b/comportement/Hyper_elastique/IsoHyper3DOrgeas2.cc @@ -1101,7 +1101,7 @@ int IsoHyper3DOrgeas2::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void IsoHyper3DOrgeas2::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void IsoHyper3DOrgeas2::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -1248,7 +1248,7 @@ void IsoHyper3DOrgeas2::Lecture_base_info_loi(ifstream& ent,const int cas,LesRef // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void IsoHyper3DOrgeas2::Ecriture_base_info_loi(ofstream& sort,const int cas) +void IsoHyper3DOrgeas2::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " module_dilatation " << K << " cas_Q0s_thermo_dependant " << cas_Q0s_thermo_dependant; if (cas_Q0s_thermo_dependant != 0) diff --git a/comportement/Hyper_elastique/IsoHyper3DOrgeas2.h b/comportement/Hyper_elastique/IsoHyper3DOrgeas2.h index c4de93e..ee18108 100644 --- a/comportement/Hyper_elastique/IsoHyper3DOrgeas2.h +++ b/comportement/Hyper_elastique/IsoHyper3DOrgeas2.h @@ -97,12 +97,12 @@ class IsoHyper3DOrgeas2 : // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/Hyper_elastique/IsoHyperBulk3.cc b/comportement/Hyper_elastique/IsoHyperBulk3.cc index 115e7b5..01b423f 100644 --- a/comportement/Hyper_elastique/IsoHyperBulk3.cc +++ b/comportement/Hyper_elastique/IsoHyperBulk3.cc @@ -265,7 +265,7 @@ int IsoHyperBulk3::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void IsoHyperBulk3::Lecture_base_info_loi(ifstream& ent,const int cas +void IsoHyperBulk3::Lecture_base_info_loi(istream& ent,const int cas ,LesReferences& lesRef,LesCourbes1D& lesCourbe1D,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -296,7 +296,7 @@ void IsoHyperBulk3::Lecture_base_info_loi(ifstream& ent,const int cas // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void IsoHyperBulk3::Ecriture_base_info_loi(ofstream& sort,const int cas) +void IsoHyperBulk3::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " module_dilatation " << K << " "; if (F_K_T == NULL) diff --git a/comportement/Hyper_elastique/IsoHyperBulk3.h b/comportement/Hyper_elastique/IsoHyperBulk3.h index 38d4e57..55bd298 100644 --- a/comportement/Hyper_elastique/IsoHyperBulk3.h +++ b/comportement/Hyper_elastique/IsoHyperBulk3.h @@ -93,12 +93,12 @@ class IsoHyperBulk3 : // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/Hyper_elastique/IsoHyperBulk_gene.cc b/comportement/Hyper_elastique/IsoHyperBulk_gene.cc index df320d6..45aa9b6 100755 --- a/comportement/Hyper_elastique/IsoHyperBulk_gene.cc +++ b/comportement/Hyper_elastique/IsoHyperBulk_gene.cc @@ -253,7 +253,7 @@ int IsoHyperBulk_gene::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void IsoHyperBulk_gene::Lecture_base_info_loi(ifstream& ent,const int cas +void IsoHyperBulk_gene::Lecture_base_info_loi(istream& ent,const int cas ,LesReferences& lesRef,LesCourbes1D& lesCourbe1D,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -283,7 +283,7 @@ void IsoHyperBulk_gene::Lecture_base_info_loi(ifstream& ent,const int cas // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void IsoHyperBulk_gene::Ecriture_base_info_loi(ofstream& sort,const int cas) +void IsoHyperBulk_gene::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { if (F_w_V == NULL) { sort << " F_w_V " << " 0 ";} diff --git a/comportement/Hyper_elastique/IsoHyperBulk_gene.h b/comportement/Hyper_elastique/IsoHyperBulk_gene.h index 2d6205f..d74ebd3 100755 --- a/comportement/Hyper_elastique/IsoHyperBulk_gene.h +++ b/comportement/Hyper_elastique/IsoHyperBulk_gene.h @@ -93,12 +93,12 @@ class IsoHyperBulk_gene : // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/Hyper_elastique/Maheo_hyper.cc b/comportement/Hyper_elastique/Maheo_hyper.cc index 4b0473f..c18b901 100755 --- a/comportement/Hyper_elastique/Maheo_hyper.cc +++ b/comportement/Hyper_elastique/Maheo_hyper.cc @@ -517,7 +517,7 @@ int Maheo_hyper::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Maheo_hyper::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Maheo_hyper::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; bool test; if (cas == 1) @@ -603,7 +603,7 @@ void Maheo_hyper::Lecture_base_info_loi(ifstream& ent,const int cas,LesReference // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Maheo_hyper::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Maheo_hyper::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { // Qsig_rev sort << " Qsig_rev= "; diff --git a/comportement/Hyper_elastique/Maheo_hyper.h b/comportement/Hyper_elastique/Maheo_hyper.h index 1881e62..e8afcf3 100755 --- a/comportement/Hyper_elastique/Maheo_hyper.h +++ b/comportement/Hyper_elastique/Maheo_hyper.h @@ -124,12 +124,12 @@ class Maheo_hyper : public Hyper_W_gene_3D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, // c'est sans doute complètement débile mais c'est pour pouvoir avancer !! diff --git a/comportement/Hyper_elastique/MooneyRivlin1D.cc b/comportement/Hyper_elastique/MooneyRivlin1D.cc index 1b70d9f..29cc0b4 100644 --- a/comportement/Hyper_elastique/MooneyRivlin1D.cc +++ b/comportement/Hyper_elastique/MooneyRivlin1D.cc @@ -234,7 +234,7 @@ int MooneyRivlin1D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void MooneyRivlin1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void MooneyRivlin1D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom;bool test; if (cas == 1) @@ -287,7 +287,7 @@ void MooneyRivlin1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefere // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void MooneyRivlin1D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void MooneyRivlin1D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { // les coefficients sort << "\n C01= "; diff --git a/comportement/Hyper_elastique/MooneyRivlin1D.h b/comportement/Hyper_elastique/MooneyRivlin1D.h index 68fecb1..a5db687 100644 --- a/comportement/Hyper_elastique/MooneyRivlin1D.h +++ b/comportement/Hyper_elastique/MooneyRivlin1D.h @@ -107,12 +107,12 @@ class MooneyRivlin1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, // c'est sans doute complètement débile mais c'est pour pouvoir avancer !! diff --git a/comportement/Hyper_elastique/MooneyRivlin3D.cc b/comportement/Hyper_elastique/MooneyRivlin3D.cc index e7eb7d7..78afc05 100644 --- a/comportement/Hyper_elastique/MooneyRivlin3D.cc +++ b/comportement/Hyper_elastique/MooneyRivlin3D.cc @@ -761,7 +761,7 @@ int MooneyRivlin3D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void MooneyRivlin3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void MooneyRivlin3D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) {string nom; bool test; if (cas == 1) @@ -909,7 +909,7 @@ void MooneyRivlin3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefere // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void MooneyRivlin3D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void MooneyRivlin3D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { // --- les coefficients // C01 diff --git a/comportement/Hyper_elastique/MooneyRivlin3D.h b/comportement/Hyper_elastique/MooneyRivlin3D.h index 058aa54..acba512 100644 --- a/comportement/Hyper_elastique/MooneyRivlin3D.h +++ b/comportement/Hyper_elastique/MooneyRivlin3D.h @@ -126,12 +126,12 @@ class MooneyRivlin3D : public Hyper_W_gene_3D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, // c'est sans doute complètement débile mais c'est pour pouvoir avancer !! diff --git a/comportement/Hyper_elastique/Poly_hyper3D.cc b/comportement/Hyper_elastique/Poly_hyper3D.cc index cc645f3..bfc49e9 100644 --- a/comportement/Hyper_elastique/Poly_hyper3D.cc +++ b/comportement/Hyper_elastique/Poly_hyper3D.cc @@ -780,7 +780,7 @@ int Poly_hyper3D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Poly_hyper3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Poly_hyper3D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; bool test; if (cas == 1) @@ -945,7 +945,7 @@ void Poly_hyper3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferenc // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Poly_hyper3D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Poly_hyper3D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { // le degré maxi int tai = Cij.Taille(); diff --git a/comportement/Hyper_elastique/Poly_hyper3D.h b/comportement/Hyper_elastique/Poly_hyper3D.h index 92d61ab..81d97cb 100644 --- a/comportement/Hyper_elastique/Poly_hyper3D.h +++ b/comportement/Hyper_elastique/Poly_hyper3D.h @@ -115,12 +115,12 @@ class Poly_hyper3D : public Hyper_W_gene_3D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, // c'est sans doute complètement débile mais c'est pour pouvoir avancer !! diff --git a/comportement/Hyper_elastique/TreloarN.cc b/comportement/Hyper_elastique/TreloarN.cc index b7869f1..250b1c8 100644 --- a/comportement/Hyper_elastique/TreloarN.cc +++ b/comportement/Hyper_elastique/TreloarN.cc @@ -96,7 +96,7 @@ int TreloarN::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void TreloarN::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void TreloarN::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) {ent >> toto >> K >> toto >> C;}; @@ -106,7 +106,7 @@ int TreloarN::TestComplet() // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void TreloarN::Ecriture_base_info_loi(ofstream& sort,const int cas) + void TreloarN::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) {sort << "TRELOAR" << " compressibilite " << K << " coef Treloar " << C ;} // appel de la classe mère diff --git a/comportement/Hyper_elastique/TreloarN.h b/comportement/Hyper_elastique/TreloarN.h index 596bc63..2f30b8c 100644 --- a/comportement/Hyper_elastique/TreloarN.h +++ b/comportement/Hyper_elastique/TreloarN.h @@ -91,12 +91,12 @@ void LectureDonneesParticulieres (UtilLecture * ,LesCourbes1D& lesCourbes1D // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/Hypo_elastique/Hypo_hooke1D.cc b/comportement/Hypo_elastique/Hypo_hooke1D.cc index 73c1cf6..ca9167a 100755 --- a/comportement/Hypo_elastique/Hypo_hooke1D.cc +++ b/comportement/Hypo_elastique/Hypo_hooke1D.cc @@ -71,7 +71,7 @@ Hypo_hooke1D::SaveResulLoi_Hypo1D::SaveResulLoi_Hypo1D // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Hypo_hooke1D::SaveResulLoi_Hypo1D::Lecture_base_info - (ifstream& ent,const int cas) + (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -98,7 +98,7 @@ void Hypo_hooke1D::SaveResulLoi_Hypo1D::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Hypo_hooke1D::SaveResulLoi_Hypo1D::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n HYPO_E_ISO_1D "; @@ -700,7 +700,7 @@ int Hypo_hooke1D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hypo_hooke1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef +void Hypo_hooke1D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef ,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; @@ -809,7 +809,7 @@ void Hypo_hooke1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferenc // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Hypo_hooke1D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Hypo_hooke1D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " HYPO_ELAS1D " << " type_derivee " << type_derive diff --git a/comportement/Hypo_elastique/Hypo_hooke1D.h b/comportement/Hypo_elastique/Hypo_hooke1D.h index 2699c42..d7ac299 100755 --- a/comportement/Hypo_elastique/Hypo_hooke1D.h +++ b/comportement/Hypo_elastique/Hypo_hooke1D.h @@ -139,12 +139,12 @@ class Hypo_hooke1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires void TdtversT() @@ -208,12 +208,12 @@ class Hypo_hooke1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // récupération des grandeurs particulière (hors ddl ) // correspondant à liTQ diff --git a/comportement/Hypo_elastique/Hypo_hooke2D_C.cc b/comportement/Hypo_elastique/Hypo_hooke2D_C.cc index f2e727d..48b8939 100644 --- a/comportement/Hypo_elastique/Hypo_hooke2D_C.cc +++ b/comportement/Hypo_elastique/Hypo_hooke2D_C.cc @@ -79,7 +79,7 @@ Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::~SaveResul_Hypo_hooke2D_C() // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Lecture_base_info - (ifstream& ent,const int cas) + (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -114,7 +114,7 @@ Hypo_hooke2D_C::SaveResul * Hypo_hooke2D_C::New_et_Initialise() // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Hypo_hooke2D_C::SaveResul_Hypo_hooke2D_C::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n HYPO_E_ISO_2D_C "; @@ -757,7 +757,7 @@ int Hypo_hooke2D_C::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hypo_hooke2D_C::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Hypo_hooke2D_C::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -873,7 +873,7 @@ void Hypo_hooke2D_C::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefere // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Hypo_hooke2D_C::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Hypo_hooke2D_C::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " HYPO_ELAS2D_C " << " type_derivee " << type_derive << " " ; sort << "\n compressibilite "; diff --git a/comportement/Hypo_elastique/Hypo_hooke2D_C.h b/comportement/Hypo_elastique/Hypo_hooke2D_C.h index 12d8baa..7cd37b1 100644 --- a/comportement/Hypo_elastique/Hypo_hooke2D_C.h +++ b/comportement/Hypo_elastique/Hypo_hooke2D_C.h @@ -119,11 +119,11 @@ class Hypo_hooke2D_C : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -195,12 +195,12 @@ class Hypo_hooke2D_C : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // récupération des grandeurs particulière (hors ddl ) // correspondant à liTQ diff --git a/comportement/Hypo_elastique/Hypo_hooke3D.cc b/comportement/Hypo_elastique/Hypo_hooke3D.cc index 6087ff2..0fb9f4d 100644 --- a/comportement/Hypo_elastique/Hypo_hooke3D.cc +++ b/comportement/Hypo_elastique/Hypo_hooke3D.cc @@ -66,7 +66,7 @@ Hypo_hooke3D::SaveResulLoi_Hypo3D::SaveResulLoi_Hypo3D // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Hypo_hooke3D::SaveResulLoi_Hypo3D::Lecture_base_info - (ifstream& ent,const int cas) + (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -91,7 +91,7 @@ void Hypo_hooke3D::SaveResulLoi_Hypo3D::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Hypo_hooke3D::SaveResulLoi_Hypo3D::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n HYPO_E_ISO_3D "; @@ -676,7 +676,7 @@ int Hypo_hooke3D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hypo_hooke3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef +void Hypo_hooke3D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef ,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; @@ -789,7 +789,7 @@ void Hypo_hooke3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferenc // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Hypo_hooke3D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Hypo_hooke3D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " HYPO_ELAS3D " << " type_derivee " << type_derive << " " ; sort << "\n compressibilite "; diff --git a/comportement/Hypo_elastique/Hypo_hooke3D.h b/comportement/Hypo_elastique/Hypo_hooke3D.h index 4187df5..384bf48 100644 --- a/comportement/Hypo_elastique/Hypo_hooke3D.h +++ b/comportement/Hypo_elastique/Hypo_hooke3D.h @@ -126,12 +126,12 @@ class Hypo_hooke3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires void TdtversT() @@ -185,13 +185,13 @@ class Hypo_hooke3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas + void Lecture_base_info_loi(istream& ent,const int cas ,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // récupération des grandeurs particulière (hors ddl ) // correspondant à liTQ diff --git a/comportement/LesLoisDeComp.cc b/comportement/LesLoisDeComp.cc index d9e95a8..07bc5e3 100644 --- a/comportement/LesLoisDeComp.cc +++ b/comportement/LesLoisDeComp.cc @@ -688,7 +688,7 @@ void LesLoisDeComp::MiseAJour_umat_nbincr(const int& num_incr) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void LesLoisDeComp::Lecture_base_info - (ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + (istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { // deux choses sont a récupérer : 1) la liste des références de loi, 2) les lois // tout d'abord la liste des références de loi @@ -754,7 +754,7 @@ void LesLoisDeComp::Lecture_base_info } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "LesLoisDeComp::Lecture_base_info(ifstream& ent,const int cas)" + cout << "LesLoisDeComp::Lecture_base_info(istream& ent,const int cas)" << " cas= " << cas << endl; Sortie(1); } @@ -763,7 +763,7 @@ void LesLoisDeComp::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesLoisDeComp::Ecriture_base_info(ofstream& sort,const int cas) +void LesLoisDeComp::Ecriture_base_info(ostream& sort,const int cas) { // deux choses sont a sauvegarder : 1) la liste des références de loi, 2) les lois // tout d'abord la liste des références de loi switch (cas) @@ -801,7 +801,7 @@ void LesLoisDeComp::Ecriture_base_info(ofstream& sort,const int cas) } default : { cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n"; - cout << "LesLoisDeComp::Ecriture_base_info(ofstream& sort,int cas)" + cout << "LesLoisDeComp::Ecriture_base_info(ostream& sort,int cas)" << " cas= " << cas << endl; Sortie(1); }; @@ -855,7 +855,7 @@ void LesLoisDeComp::Sortie_temps_cpu(UtilLecture& entreePrinc) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LesLoisDeComp::RefLoi::Lecture_base_info(ifstream& ent,const int cas) +void LesLoisDeComp::RefLoi::Lecture_base_info(istream& ent,const int cas) { string toto; if (cas==1) ent >> toto >> st1 >> toto >> st2; @@ -863,7 +863,7 @@ void LesLoisDeComp::RefLoi::Lecture_base_info(ifstream& ent,const int cas) // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesLoisDeComp::RefLoi::Ecriture_base_info(ofstream& sort,const int cas) const +void LesLoisDeComp::RefLoi::Ecriture_base_info(ostream& sort,const int cas) const { if (cas==1) sort << "\n nom_de_la_reference " << st1 <<" nom_de_loi "<< st2; }; @@ -916,7 +916,7 @@ ostream & operator << ( ostream & sort,const LesLoisDeComp::RefLoi & refloi) // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void LesLoisDeComp::Loi::Lecture_base_info - (ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + (istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { if (cas==1) { cout << "== lecture des lois de comportement \n"; @@ -933,7 +933,7 @@ void LesLoisDeComp::Loi::Lecture_base_info // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LesLoisDeComp::Loi::Ecriture_base_info(ofstream& sort,const int cas) +void LesLoisDeComp::Loi::Ecriture_base_info(ostream& sort,const int cas) { if (cas==1) { // la référence de la loi sort << "\n nom_de_la_reference_de_la_loi " << st1 << " " ; diff --git a/comportement/LesLoisDeComp.h b/comportement/LesLoisDeComp.h index 1827920..3b11648 100644 --- a/comportement/LesLoisDeComp.h +++ b/comportement/LesLoisDeComp.h @@ -90,11 +90,11 @@ class LesLoisDeComp // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas); + void Lecture_base_info(istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) const; + void Ecriture_base_info(ostream& sort,const int cas) const; }; class Loi {// surcharge de l'operator de lecture typée @@ -116,12 +116,12 @@ class LesLoisDeComp // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); }; friend class Loi; @@ -176,12 +176,12 @@ class LesLoisDeComp // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // définition d'un pointeur de loi en fonction d'une chaine de caractères static LoiAbstraiteGeneral * Def_loi(string & nom); diff --git a/comportement/LoiAbstraiteGeneral.cc b/comportement/LoiAbstraiteGeneral.cc index 263030c..e1e165e 100644 --- a/comportement/LoiAbstraiteGeneral.cc +++ b/comportement/LoiAbstraiteGeneral.cc @@ -85,7 +85,7 @@ int LoiAbstraiteGeneral::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LoiAbstraiteGeneral::Lect_base_info_loi (ifstream& ent,const int cas +void LoiAbstraiteGeneral::Lect_base_info_loi (istream& ent,const int cas ,LesReferences& ,LesCourbes1D& ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -108,7 +108,7 @@ void LoiAbstraiteGeneral::Lect_base_info_loi (ifstream& ent,const int cas // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LoiAbstraiteGeneral::Ecrit_base_info_loi(ofstream& sort,const int cas) const +void LoiAbstraiteGeneral::Ecrit_base_info_loi(ostream& sort,const int cas) const { if (cas == 1) { // le nom de la loi de comportement sort << "\n type_de_loi_de_comportement: " << Nom_comp(id_comp) << " " diff --git a/comportement/LoiAbstraiteGeneral.h b/comportement/LoiAbstraiteGeneral.h index e73d1a0..a7a3c3f 100644 --- a/comportement/LoiAbstraiteGeneral.h +++ b/comportement/LoiAbstraiteGeneral.h @@ -146,12 +146,12 @@ class LoiAbstraiteGeneral // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) virtual void Lecture_base_info_loi - (ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + (istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) = 0; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info_loi(ofstream& sort,const int cas) =0; + virtual void Ecriture_base_info_loi(ostream& sort,const int cas) =0; // affichage et definition interactive des commandes particulières à chaques lois virtual void Info_commande_LoisDeComp(UtilLecture& lec) = 0; @@ -203,12 +203,12 @@ class LoiAbstraiteGeneral // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Lect_base_info_loi - (ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + (istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecrit_base_info_loi(ofstream& sort,const int cas) const; + void Ecrit_base_info_loi(ostream& sort,const int cas) const; // change la catégorie de la loi de comportement void ChangeCategorie(Enum_categorie_loi_comp new_categorie) {categorie_loi_comp=new_categorie;}; diff --git a/comportement/Loi_comp_abstraite.cc b/comportement/Loi_comp_abstraite.cc index 6672cfb..c44b648 100644 --- a/comportement/Loi_comp_abstraite.cc +++ b/comportement/Loi_comp_abstraite.cc @@ -1285,7 +1285,7 @@ void Loi_comp_abstraite::Info_commande_don_LoisDeComp(UtilLecture& entreePrinc) // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_comp_abstraite::Lecture_don_base_info(ifstream& ent,const int cas,LesReferences& lesRef +void Loi_comp_abstraite::Lecture_don_base_info(istream& ent,const int cas,LesReferences& lesRef ,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; @@ -1322,7 +1322,7 @@ void Loi_comp_abstraite::Lecture_don_base_info(ifstream& ent,const int cas,LesRe // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_comp_abstraite::Ecriture_don_base_info(ofstream& sort,const int cas) const +void Loi_comp_abstraite::Ecriture_don_base_info(ostream& sort,const int cas) const { if (cas == 1) { // tout d'abord appel de la classe mère LoiAbstraiteGeneral::Ecrit_base_info_loi(sort,cas); @@ -4575,7 +4575,7 @@ int Loi_comp_abstraite::Cal_permet_affichage() }; - void Loi_comp_abstraite::Affiche_niveau_affichage(ofstream& sort,const int cas) + void Loi_comp_abstraite::Affiche_niveau_affichage(ostream& sort,const int cas) { // on traite en fonction de l'existance ou non d'une fonction nD if (permet_affich_loi_nD != NULL) {sort << " 1 permet_affich_loi_nD: "; @@ -4585,7 +4585,7 @@ int Loi_comp_abstraite::Cal_permet_affichage() {sort << " 0 " << permet_affich_loi ; }; }; void Loi_comp_abstraite::Lecture_permet_affichage - (ifstream& ent,const int cas,LesFonctions_nD& lesFonctionsnD) + (istream& ent,const int cas,LesFonctions_nD& lesFonctionsnD) { // on traite en fonction de l'existance ou non d'une fonction nD int test =0;string nom; diff --git a/comportement/Loi_comp_abstraite.h b/comportement/Loi_comp_abstraite.h index 24e390c..790bbd6 100644 --- a/comportement/Loi_comp_abstraite.h +++ b/comportement/Loi_comp_abstraite.h @@ -139,11 +139,11 @@ class Loi_comp_abstraite : public LoiAbstraiteGeneral // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info (ifstream& ent,const int cas) = 0; + virtual void Lecture_base_info (istream& ent,const int cas) = 0; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int cas) = 0; + virtual void Ecriture_base_info(ostream& sort,const int cas) = 0; // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -210,7 +210,7 @@ class Loi_comp_abstraite : public LoiAbstraiteGeneral // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) - virtual void AfficheDataSpecif(ofstream& ,SaveResul * ) const {}; + virtual void AfficheDataSpecif(ostream& ,SaveResul * ) const {}; //----------------------------------------- classe SaveResul_C --------------------------------- // cette classe permet de gérer une ou plusieurs contraintes, qui peuvent conduire à annuler l'action des contraintes @@ -229,12 +229,12 @@ class Loi_comp_abstraite : public LoiAbstraiteGeneral // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - virtual void Lecture_base_info (ifstream& ent,const int ) + virtual void Lecture_base_info (istream& ent,const int ) {string toto; ent >> toto >> actif_t ;}; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - virtual void Ecriture_base_info(ofstream& sort,const int ) + virtual void Ecriture_base_info(ostream& sort,const int ) {sort << "\n actif_t= " << actif_t << " ";}; // mise à jour des informations transitoires en définitif s'il y a convergence @@ -495,12 +495,12 @@ class Loi_comp_abstraite : public LoiAbstraiteGeneral // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_don_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_don_base_info(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_don_base_info(ofstream& sort,const int cas) const; + void Ecriture_don_base_info(ostream& sort,const int cas) const; // activation des données des noeuds et/ou elements nécessaires au fonctionnement de la loi // exemple: mise en service des ddl de température aux noeuds // méthode appelée par Activation_donnees principal, ou des classes dérivées @@ -607,8 +607,8 @@ Tableau & Loi_comp_Valeur_FnD_Evoluee void Lecture_permet_affichage(UtilLecture * entreePrinc,LesFonctions_nD& lesFonctionsnD); // sortie du niveau d'affichage void Affiche_niveau_affichage()const; - void Affiche_niveau_affichage(ofstream& sort,const int cas); - void Lecture_permet_affichage(ifstream& ent,const int cas,LesFonctions_nD& lesFonctionsnD); + void Affiche_niveau_affichage(ostream& sort,const int cas); + void Lecture_permet_affichage(istream& ent,const int cas,LesFonctions_nD& lesFonctionsnD); // VARIABLES PROTEGEES : // pointeur de travail utilise par les classes derivantes diff --git a/comportement/anisotropie/Hypo_ortho3D_entrainee.cc b/comportement/anisotropie/Hypo_ortho3D_entrainee.cc index 1d4d380..150711b 100755 --- a/comportement/anisotropie/Hypo_ortho3D_entrainee.cc +++ b/comportement/anisotropie/Hypo_ortho3D_entrainee.cc @@ -177,7 +177,7 @@ Loi_comp_abstraite::SaveResul & Hypo_ortho3D_entrainee::SaveResulHypo_ortho3D_en // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hypo_ortho3D_entrainee::SaveResulHypo_ortho3D_entrainee::Lecture_base_info(ifstream& ent,const int cas) +void Hypo_ortho3D_entrainee::SaveResulHypo_ortho3D_entrainee::Lecture_base_info(istream& ent,const int cas) { string nom; ent >> nom ; @@ -274,7 +274,7 @@ void Hypo_ortho3D_entrainee::SaveResulHypo_ortho3D_entrainee::Lecture_base_info( // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Hypo_ortho3D_entrainee::SaveResulHypo_ortho3D_entrainee::Ecriture_base_info(ofstream& sort,const int cas ) +void Hypo_ortho3D_entrainee::SaveResulHypo_ortho3D_entrainee::Ecriture_base_info(ostream& sort,const int cas ) { sort << "\n S_Ortho_3D "; // on ne sauvegarde que ce qui est à 0 et à t, ce qui est à tdt est considéré une zone de travail switch (cas) @@ -1157,7 +1157,7 @@ void Hypo_ortho3D_entrainee::ListeGrandeurs_particulieres(bool absolue,List_io> nom ; @@ -231,7 +231,7 @@ void Loi_ortho2D_C_entrainee::SaveResulLoi_ortho2D_C_entrainee::Lecture_base_inf // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Loi_ortho2D_C_entrainee::SaveResulLoi_ortho2D_C_entrainee::Ecriture_base_info(ofstream& sort,const int cas ) +void Loi_ortho2D_C_entrainee::SaveResulLoi_ortho2D_C_entrainee::Ecriture_base_info(ostream& sort,const int cas ) { sort << "\n S_Ortho_2D_C "; // on ne sauvegarde que ce qui est à 0 et à t, ce qui est à tdt est considéré une zone de travail switch (cas) @@ -1071,7 +1071,7 @@ void Loi_ortho2D_C_entrainee::ListeGrandeurs_particulieres(bool absolue,List_io< // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_ortho2D_C_entrainee::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_ortho2D_C_entrainee::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto,nom; if (cas == 1) @@ -1124,7 +1124,7 @@ void Loi_ortho2D_C_entrainee::Lecture_base_info_loi(ifstream& ent,const int cas, // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_ortho2D_C_entrainee::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_ortho2D_C_entrainee::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " ORTHOELA2D_C " ; // pour faire une boucle on constitue un tableau de mots clés diff --git a/comportement/anisotropie/Loi_ortho2D_C_entrainee.h b/comportement/anisotropie/Loi_ortho2D_C_entrainee.h index 22dc3ca..caa4ffb 100755 --- a/comportement/anisotropie/Loi_ortho2D_C_entrainee.h +++ b/comportement/anisotropie/Loi_ortho2D_C_entrainee.h @@ -122,11 +122,11 @@ class Loi_ortho2D_C_entrainee : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires void TdtversT(); @@ -220,12 +220,12 @@ class Loi_ortho2D_C_entrainee : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/anisotropie/Loi_ortho3D_entrainee.cc b/comportement/anisotropie/Loi_ortho3D_entrainee.cc index 43da32b..885117f 100755 --- a/comportement/anisotropie/Loi_ortho3D_entrainee.cc +++ b/comportement/anisotropie/Loi_ortho3D_entrainee.cc @@ -152,7 +152,7 @@ Loi_comp_abstraite::SaveResul & Loi_ortho_elas3D::SaveResulLoi_ortho_elas3D::ope // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_ortho_elas3D::SaveResulLoi_ortho_elas3D::Lecture_base_info(ifstream& ent,const int cas) +void Loi_ortho_elas3D::SaveResulLoi_ortho_elas3D::Lecture_base_info(istream& ent,const int cas) { string nom; ent >> nom ; @@ -233,7 +233,7 @@ void Loi_ortho_elas3D::SaveResulLoi_ortho_elas3D::Lecture_base_info(ifstream& en // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Loi_ortho_elas3D::SaveResulLoi_ortho_elas3D::Ecriture_base_info(ofstream& sort,const int cas ) +void Loi_ortho_elas3D::SaveResulLoi_ortho_elas3D::Ecriture_base_info(ostream& sort,const int cas ) { sort << "\n S_Ortho_3D "; // on ne sauvegarde que ce qui est à 0 et à t, ce qui est à tdt est considéré une zone de travail switch (cas) @@ -1062,7 +1062,7 @@ void Loi_ortho_elas3D::ListeGrandeurs_particulieres(bool absolue,List_io> nom ; @@ -376,7 +376,7 @@ void Projection_anisotrope_3D::SaveResulProjection_anisotrope_3D::Lecture_base_i // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Projection_anisotrope_3D::SaveResulProjection_anisotrope_3D::Ecriture_base_info(ofstream& sort,const int cas ) +void Projection_anisotrope_3D::SaveResulProjection_anisotrope_3D::Ecriture_base_info(ostream& sort, int cas ) { sort << "\n S_Proj_aniso_3D "; // tout d'abord ce qui varie tout le temps // pondération ? @@ -1437,7 +1437,7 @@ Enum_comp_3D_CP_DP_1D Projection_anisotrope_3D::Comportement_3D_CP_DP_1D() // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Projection_anisotrope_3D::Lecture_base_info_loi - (ifstream& ent,const int cas,LesReferences& lesRef + (istream& ent,const int cas,LesReferences& lesRef ,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto,nom; @@ -1564,7 +1564,7 @@ void Projection_anisotrope_3D::Lecture_base_info_loi // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Projection_anisotrope_3D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Projection_anisotrope_3D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " PROJECTION_ANISOTROPE_3D " ; // on indique le type de projection diff --git a/comportement/anisotropie/Projection_anisotrope_3D.h b/comportement/anisotropie/Projection_anisotrope_3D.h index 6baccba..dccaf70 100755 --- a/comportement/anisotropie/Projection_anisotrope_3D.h +++ b/comportement/anisotropie/Projection_anisotrope_3D.h @@ -141,11 +141,11 @@ class Projection_anisotrope_3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent, int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires void TdtversT(); @@ -263,12 +263,12 @@ class Projection_anisotrope_3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/hysteresis/Hysteresis1D.cc b/comportement/hysteresis/Hysteresis1D.cc index c401f5a..ce494d6 100644 --- a/comportement/hysteresis/Hysteresis1D.cc +++ b/comportement/hysteresis/Hysteresis1D.cc @@ -100,7 +100,7 @@ Loi_comp_abstraite::SaveResul & Hysteresis1D::SaveResulHysteresis1D::operator = // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hysteresis1D::SaveResulHysteresis1D::Lecture_base_info (ifstream& ent,const int ) +void Hysteresis1D::SaveResulHysteresis1D::Lecture_base_info (istream& ent,const int ) { // ici toutes les données sont toujours a priori variables string toto; ent >> toto >> sigma_barre_BH_t ;sigma_barre_BH_tdt = sigma_barre_BH_t; @@ -148,7 +148,7 @@ void Hysteresis1D::SaveResulHysteresis1D::Lecture_base_info (ifstream& ent,const // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Hysteresis1D::SaveResulHysteresis1D::Ecriture_base_info(ofstream& sort,const int ) +void Hysteresis1D::SaveResulHysteresis1D::Ecriture_base_info(ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables sort << " sigma_barre_BH_t " << sigma_barre_BH_t; sort << " fct_aide_t " << fonction_aide_t; @@ -1363,7 +1363,7 @@ void Hysteresis1D::Calcul_DsigmaHH_tdt (TenseurHH & sigHH_t,TenseurBB& ,DdlEleme // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hysteresis1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Hysteresis1D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -1412,7 +1412,7 @@ void Hysteresis1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferenc // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Hysteresis1D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Hysteresis1D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " HYSTERESIS_1D "; sort << " param_prager_(np) "; diff --git a/comportement/hysteresis/Hysteresis1D.h b/comportement/hysteresis/Hysteresis1D.h index ffadc36..09a58ed 100644 --- a/comportement/hysteresis/Hysteresis1D.h +++ b/comportement/hysteresis/Hysteresis1D.h @@ -124,11 +124,11 @@ class Hysteresis1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires void TdtversT(); @@ -224,13 +224,13 @@ class Hysteresis1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/hysteresis/Hysteresis3D.cc b/comportement/hysteresis/Hysteresis3D.cc index f01f329..3db966b 100644 --- a/comportement/hysteresis/Hysteresis3D.cc +++ b/comportement/hysteresis/Hysteresis3D.cc @@ -139,7 +139,7 @@ Loi_comp_abstraite::SaveResul & Hysteresis3D::SaveResulHysteresis3D::operator = // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hysteresis3D::SaveResulHysteresis3D::Lecture_base_info (ifstream& ent,const int ) +void Hysteresis3D::SaveResulHysteresis3D::Lecture_base_info (istream& ent,const int ) { // ici toutes les données sont toujours a priori variables string toto; ent >> toto >> sigma_barre_BH_t ;sigma_barre_BH_tdt = sigma_barre_BH_t; @@ -234,7 +234,7 @@ void Hysteresis3D::SaveResulHysteresis3D::Lecture_base_info (ifstream& ent,const // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Hysteresis3D::SaveResulHysteresis3D::Ecriture_base_info(ofstream& sort,const int ) +void Hysteresis3D::SaveResulHysteresis3D::Ecriture_base_info(ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables sort << " sigma_barre_BH_t " << sigma_barre_BH_t; sort << "\n oc_BH_t " << oc_BH_t; @@ -2182,7 +2182,7 @@ void Hysteresis3D::ListeGrandeurs_particulieres(bool absolue,List_io> toto >> MPr_t ;MPr_tdt = MPr_t; @@ -166,7 +166,7 @@ void Hysteresis_bulk::SaveResulHysteresis_bulk::Lecture_base_info (ifstream& ent // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) -void Hysteresis_bulk::SaveResulHysteresis_bulk::Ecriture_base_info(ofstream& sort,const int ) +void Hysteresis_bulk::SaveResulHysteresis_bulk::Ecriture_base_info(ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables sort << " MPr_t " << MPr_t; sort << " fct_aide_t " << fonction_aide_t; @@ -1681,7 +1681,7 @@ void Hysteresis_bulk::Calcul_dsigma_deps (bool en_base_orthonormee, TenseurHH & // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hysteresis_bulk::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Hysteresis_bulk::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) {string toto; if (cas == 1) @@ -1731,7 +1731,7 @@ void Hysteresis_bulk::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefer // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Hysteresis_bulk::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Hysteresis_bulk::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " HYSTERESIS_BULK "; sort << " param_prager_(np) "; diff --git a/comportement/hysteresis/Hysteresis_bulk.h b/comportement/hysteresis/Hysteresis_bulk.h index a37ff00..568cc6d 100755 --- a/comportement/hysteresis/Hysteresis_bulk.h +++ b/comportement/hysteresis/Hysteresis_bulk.h @@ -113,11 +113,11 @@ class Hysteresis_bulk : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires void TdtversT(); @@ -231,13 +231,13 @@ class Hysteresis_bulk : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/iso_elas_hooke/Loi_iso_elas1D.cc b/comportement/iso_elas_hooke/Loi_iso_elas1D.cc index 72ddf18..62d7754 100644 --- a/comportement/iso_elas_hooke/Loi_iso_elas1D.cc +++ b/comportement/iso_elas_hooke/Loi_iso_elas1D.cc @@ -506,7 +506,7 @@ void Loi_iso_elas1D::ListeGrandeurs_particulieres(bool absolue,List_io> toto >> E >> toto >> nu; E_t=E; nu_t = nu; }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) + void Ecriture_base_info(ostream& sort,const int cas) {sort << "\n E= "<< E <<" nu= "<< nu << " ";}; // mise à jour des informations transitoires @@ -219,12 +219,12 @@ class Loi_iso_elas1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupŹre tout // = 2 : on récupŹre uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent √ la loi, ceci pour un // chargement nul diff --git a/comportement/iso_elas_hooke/Loi_iso_elas2D_C.cc b/comportement/iso_elas_hooke/Loi_iso_elas2D_C.cc index 733209d..e3d441a 100644 --- a/comportement/iso_elas_hooke/Loi_iso_elas2D_C.cc +++ b/comportement/iso_elas_hooke/Loi_iso_elas2D_C.cc @@ -103,7 +103,7 @@ void Loi_iso_elas2D_C::SaveResul_Loi_iso_elas2D_C::Mise_a_jour_map_type_quelconq // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Loi_iso_elas2D_C::SaveResul_Loi_iso_elas2D_C::Lecture_base_info - (ifstream& ent,const int cas) + (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -126,7 +126,7 @@ void Loi_iso_elas2D_C::SaveResul_Loi_iso_elas2D_C::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Loi_iso_elas2D_C::SaveResul_Loi_iso_elas2D_C::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n E_ISO_2D_C "; @@ -417,7 +417,7 @@ void Loi_iso_elas2D_C::Affiche() const // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_iso_elas2D_C::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_iso_elas2D_C::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto,nom; if (cas == 1) @@ -504,7 +504,7 @@ void Loi_iso_elas2D_C::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefe // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_iso_elas2D_C::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_iso_elas2D_C::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " ISOELAS2D_C " << thermo_dependant << " module Young: " ; // tout d'abord le module d'Young diff --git a/comportement/iso_elas_hooke/Loi_iso_elas2D_C.h b/comportement/iso_elas_hooke/Loi_iso_elas2D_C.h index 7f813a1..9410348 100644 --- a/comportement/iso_elas_hooke/Loi_iso_elas2D_C.h +++ b/comportement/iso_elas_hooke/Loi_iso_elas2D_C.h @@ -121,11 +121,11 @@ class Loi_iso_elas2D_C : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -237,12 +237,12 @@ class Loi_iso_elas2D_C : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde toutg,const VariablesTemps& // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/iso_elas_hooke/Loi_iso_elas2D_D.cc b/comportement/iso_elas_hooke/Loi_iso_elas2D_D.cc index fc2e400..dfc927b 100644 --- a/comportement/iso_elas_hooke/Loi_iso_elas2D_D.cc +++ b/comportement/iso_elas_hooke/Loi_iso_elas2D_D.cc @@ -529,7 +529,7 @@ void Loi_iso_elas2D_D::ListeGrandeurs_particulieres(bool absolue,List_io> toto >> E >> toto >> nu; E_t=E; nu_t = nu; }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) + void Ecriture_base_info(ostream& sort,const int cas) {sort << "\n E= "<< E <<" nu= "<< nu << " ";}; // mise à jour des informations transitoires @@ -225,12 +225,12 @@ class Loi_iso_elas2D_D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/iso_elas_hooke/Loi_iso_elas3D.cc b/comportement/iso_elas_hooke/Loi_iso_elas3D.cc index b952ac5..a0b0d8d 100644 --- a/comportement/iso_elas_hooke/Loi_iso_elas3D.cc +++ b/comportement/iso_elas_hooke/Loi_iso_elas3D.cc @@ -532,7 +532,7 @@ void Loi_iso_elas3D::ListeGrandeurs_particulieres(bool absolue,List_io> toto >> E >> toto >> nu; E_t=E; nu_t = nu; }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) + void Ecriture_base_info(ostream& sort,const int cas) {sort << "\n E= "<< E <<" nu= "<< nu << " ";}; // mise à jour des informations transitoires @@ -229,12 +229,12 @@ class Loi_iso_elas3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/iso_elas_nonlinear/Iso_elas_SE1D.cc b/comportement/iso_elas_nonlinear/Iso_elas_SE1D.cc index 7f5fd3f..ea84747 100644 --- a/comportement/iso_elas_nonlinear/Iso_elas_SE1D.cc +++ b/comportement/iso_elas_nonlinear/Iso_elas_SE1D.cc @@ -176,7 +176,7 @@ int Iso_elas_SE1D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Iso_elas_SE1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Iso_elas_SE1D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -198,7 +198,7 @@ void Iso_elas_SE1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferen // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Iso_elas_SE1D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Iso_elas_SE1D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { // la courbe f(epsilon) sort << " \n symetrie " << symetrique << " fonction_epsilon "; diff --git a/comportement/iso_elas_nonlinear/Iso_elas_SE1D.h b/comportement/iso_elas_nonlinear/Iso_elas_SE1D.h index b92fd47..fb7191f 100644 --- a/comportement/iso_elas_nonlinear/Iso_elas_SE1D.h +++ b/comportement/iso_elas_nonlinear/Iso_elas_SE1D.h @@ -114,12 +114,12 @@ class Iso_elas_SE1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/iso_elas_nonlinear/Iso_elas_expo1D.cc b/comportement/iso_elas_nonlinear/Iso_elas_expo1D.cc index 479f79e..f01357c 100644 --- a/comportement/iso_elas_nonlinear/Iso_elas_expo1D.cc +++ b/comportement/iso_elas_nonlinear/Iso_elas_expo1D.cc @@ -509,7 +509,7 @@ void Iso_elas_expo1D::ListeGrandeurs_particulieres(bool absolue,List_io> toto >> E >> toto >> nu; E_t=E; nu_t = nu; }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) + void Ecriture_base_info(ostream& sort,const int cas) {sort << "\n E= "<< E <<" nu= "<< nu << " ";}; // mise à jour des informations transitoires @@ -205,12 +205,12 @@ class Iso_elas_expo1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent √ la loi, ceci pour un diff --git a/comportement/iso_elas_nonlinear/Iso_elas_expo3D.h b/comportement/iso_elas_nonlinear/Iso_elas_expo3D.h index 62aabef..012d026 100644 --- a/comportement/iso_elas_nonlinear/Iso_elas_expo3D.h +++ b/comportement/iso_elas_nonlinear/Iso_elas_expo3D.h @@ -102,12 +102,12 @@ class Iso_elas_expo3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi pour un chargement nul double Module_young_equivalent(Enum_dure temps,const Deformation & def,SaveResul * saveResul); diff --git a/comportement/iso_elas_nonlinear/iso_elas_expo3D.cc b/comportement/iso_elas_nonlinear/iso_elas_expo3D.cc index a9df7d2..ec70796 100644 --- a/comportement/iso_elas_nonlinear/iso_elas_expo3D.cc +++ b/comportement/iso_elas_nonlinear/iso_elas_expo3D.cc @@ -185,7 +185,7 @@ int Iso_elas_expo3D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Iso_elas_expo3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Iso_elas_expo3D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -205,7 +205,7 @@ void Iso_elas_expo3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefer // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Iso_elas_expo3D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Iso_elas_expo3D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " module_d'young " << E << " nu " << nu ; // la courbe de coefficient multiplicatif diff --git a/comportement/loi_Umat/Loi_Umat.cc b/comportement/loi_Umat/Loi_Umat.cc index 0c1fc62..8c0dcd3 100644 --- a/comportement/loi_Umat/Loi_Umat.cc +++ b/comportement/loi_Umat/Loi_Umat.cc @@ -96,7 +96,7 @@ Loi_comp_abstraite::SaveResul & // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_Umat::SaveResul_Loi_Umat::Lecture_base_info (ifstream& ent,const int cas) +void Loi_Umat::SaveResul_Loi_Umat::Lecture_base_info (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -119,7 +119,7 @@ void Loi_Umat::SaveResul_Loi_Umat::Lecture_base_info (ifstream& ent,const int ca // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_Umat::SaveResul_Loi_Umat::Ecriture_base_info (ofstream& sort,const int cas) +void Loi_Umat::SaveResul_Loi_Umat::Ecriture_base_info (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n S_R_LoiUmat "; @@ -495,7 +495,7 @@ int Loi_Umat::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_Umat::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_Umat::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto,nom; if (cas == 1) @@ -509,7 +509,7 @@ void Loi_Umat::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_Umat::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_Umat::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " " << Nom_comp(this->Id_comport()) << " " << thermo_dependant; }; diff --git a/comportement/loi_Umat/Loi_Umat.h b/comportement/loi_Umat/Loi_Umat.h index d980f99..8e52198 100644 --- a/comportement/loi_Umat/Loi_Umat.h +++ b/comportement/loi_Umat/Loi_Umat.h @@ -120,11 +120,11 @@ class Loi_Umat : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -200,12 +200,12 @@ class Loi_Umat : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/lois_combinees/LoiAdditiveEnSigma.cc b/comportement/lois_combinees/LoiAdditiveEnSigma.cc index 0f1352d..e87c484 100644 --- a/comportement/lois_combinees/LoiAdditiveEnSigma.cc +++ b/comportement/lois_combinees/LoiAdditiveEnSigma.cc @@ -89,7 +89,7 @@ LoiAdditiveEnSigma::SaveResul_LoiAdditiveEnSigma::SaveResul_LoiAdditiveEnSigma //---fin debug }; //---debug -//ofstream fichier("toto", ios::app); +//ostream fichier("toto", ios::app); //fichier << "\n un saveresult de loi additive : constructeur courant "; //this->Ecriture_base_info(fichier,1); //---fin debug @@ -109,7 +109,7 @@ LoiAdditiveEnSigma::SaveResul_LoiAdditiveEnSigma::SaveResul_LoiAdditiveEnSigma if ((*ili) != NULL) nevez_save_result = (*ili)->Nevez_SaveResul(); liste_des_SaveResul.push_back(nevez_save_result); //---debug -//ofstream fichier("toto", ios::app); +//ostream fichier("toto", ios::app); //fichier << "\n un constructeur de copie "; //fichier << "\n ------ save result interne : "; //if (nevez_save_result != NULL) nevez_save_result->Ecriture_base_info(fichier,1); @@ -212,7 +212,7 @@ Loi_comp_abstraite::SaveResul & // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void LoiAdditiveEnSigma::SaveResul_LoiAdditiveEnSigma::Lecture_base_info - (ifstream& ent,const int cas) + (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -274,7 +274,7 @@ void LoiAdditiveEnSigma::SaveResul_LoiAdditiveEnSigma::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void LoiAdditiveEnSigma::SaveResul_LoiAdditiveEnSigma::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n S_R_LoiAdSig "; @@ -1396,7 +1396,7 @@ Enum_comp_3D_CP_DP_1D LoiAdditiveEnSigma::Comportement_3D_CP_DP_1D() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void LoiAdditiveEnSigma::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void LoiAdditiveEnSigma::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { if (cas == 1) { string st1,st2,nom_completude_calcul; int nb_loi; @@ -1496,7 +1496,7 @@ Enum_comp_3D_CP_DP_1D LoiAdditiveEnSigma::Comportement_3D_CP_DP_1D() // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LoiAdditiveEnSigma::Ecriture_base_info_loi(ofstream& sort,const int cas) +void LoiAdditiveEnSigma::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << "\n loiAdditiveEnSigma " << lois_internes.size() << " tangent_ddl_via_eps= "<< tangent_ddl_via_eps <<" "; diff --git a/comportement/lois_combinees/LoiAdditiveEnSigma.h b/comportement/lois_combinees/LoiAdditiveEnSigma.h index a701055..f9b91f1 100644 --- a/comportement/lois_combinees/LoiAdditiveEnSigma.h +++ b/comportement/lois_combinees/LoiAdditiveEnSigma.h @@ -125,11 +125,11 @@ class LoiAdditiveEnSigma : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -225,13 +225,13 @@ class LoiAdditiveEnSigma : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/lois_combinees/LoiContraintesPlanes.cc b/comportement/lois_combinees/LoiContraintesPlanes.cc index b8feb60..7c1e0e9 100644 --- a/comportement/lois_combinees/LoiContraintesPlanes.cc +++ b/comportement/lois_combinees/LoiContraintesPlanes.cc @@ -198,7 +198,7 @@ Loi_comp_abstraite::SaveResul & // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void LoiContraintesPlanes::SaveResul_LoiContraintesPlanes::Lecture_base_info - (ifstream& ent,const int cas) + (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -280,7 +280,7 @@ void LoiContraintesPlanes::SaveResul_LoiContraintesPlanes::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void LoiContraintesPlanes::SaveResul_LoiContraintesPlanes::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n S_C_Plane "; @@ -1732,7 +1732,7 @@ void LoiContraintesPlanes::ListeGrandeurs_particulieres(bool absolue,List_io> toto; @@ -155,7 +155,7 @@ void LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void LoiDeformationsPlanes::SaveResul_LoiDeformationsPlanes::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n S_D_Plane "; @@ -701,7 +701,7 @@ void LoiDeformationsPlanes::ListeGrandeurs_particulieres(bool absolue,List_io> toto; @@ -295,7 +295,7 @@ void LoiDesMelangesEnSigma::SaveResul_LoiDesMelangesEnSigma::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void LoiDesMelangesEnSigma::SaveResul_LoiDesMelangesEnSigma::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici la majorité des données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n S_R_LoiMeSig "; @@ -1643,7 +1643,7 @@ Enum_comp_3D_CP_DP_1D LoiDesMelangesEnSigma::Comportement_3D_CP_DP_1D() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void LoiDesMelangesEnSigma::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void LoiDesMelangesEnSigma::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { if (cas == 1) { string st1; string nom; @@ -1732,7 +1732,7 @@ void LoiDesMelangesEnSigma::Lecture_base_info_loi(ifstream& ent,const int cas,Le // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void LoiDesMelangesEnSigma::Ecriture_base_info_loi(ofstream& sort,const int cas) +void LoiDesMelangesEnSigma::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << "\n LOI_DES_MELANGES_EN_SIGMA " << "\n type_de_melange: "<> toto >> eps33_t >> toto >> Deps33_t; @@ -68,7 +68,7 @@ void Loi_maxwell2D_C::SaveResul_Loi_maxwell2D_C::Lecture_base_info // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) void Loi_maxwell2D_C::SaveResul_Loi_maxwell2D_C::Ecriture_base_info - (ofstream& sort,const int ) + (ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables sort << " eps33_t " << eps33_t << " Deps33_t " << Deps33_t << " " ; }; @@ -707,7 +707,7 @@ double Loi_maxwell2D_C::Module_young_equivalent(Enum_dure temps,const Deformatio // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_maxwell2D_C::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_maxwell2D_C::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -776,7 +776,7 @@ void Loi_maxwell2D_C::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefer // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_maxwell2D_C::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_maxwell2D_C::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " maxwell2D_C " << " type_derivee " << type_derive << " "; sort << "\n module_d_young "; diff --git a/comportement/lois_visco_elastiques/Loi_maxwell2D_C.h b/comportement/lois_visco_elastiques/Loi_maxwell2D_C.h index 4002795..ead35b0 100644 --- a/comportement/lois_visco_elastiques/Loi_maxwell2D_C.h +++ b/comportement/lois_visco_elastiques/Loi_maxwell2D_C.h @@ -121,11 +121,11 @@ class Loi_maxwell2D_C : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -191,13 +191,13 @@ class Loi_maxwell2D_C : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/lois_visco_elastiques/Loi_maxwell2D_D.cc b/comportement/lois_visco_elastiques/Loi_maxwell2D_D.cc index d666f5e..180de3a 100644 --- a/comportement/lois_visco_elastiques/Loi_maxwell2D_D.cc +++ b/comportement/lois_visco_elastiques/Loi_maxwell2D_D.cc @@ -53,7 +53,7 @@ using namespace std; //introduces namespace std // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Loi_maxwell2D_D::SaveResul_Loi_maxwell2D_D::Lecture_base_info - (ifstream& ent,const int ) + (istream& ent,const int ) { // ici toutes les données sont toujours a priori variables string toto; ent >> toto >> sig33_t; @@ -64,7 +64,7 @@ void Loi_maxwell2D_D::SaveResul_Loi_maxwell2D_D::Lecture_base_info // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) void Loi_maxwell2D_D::SaveResul_Loi_maxwell2D_D::Ecriture_base_info - (ofstream& sort,const int ) + (ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables sort << " sig33_t " << sig33_t << " " ; }; @@ -702,7 +702,7 @@ double Loi_maxwell2D_D::Module_young_equivalent(Enum_dure temps,const Deformatio // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_maxwell2D_D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_maxwell2D_D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -771,7 +771,7 @@ void Loi_maxwell2D_D::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefer // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_maxwell2D_D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_maxwell2D_D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " maxwell2D_D " << " type_derivee " << type_derive << " seule_deviatorique= " << seule_deviatorique << " "; diff --git a/comportement/lois_visco_elastiques/Loi_maxwell2D_D.h b/comportement/lois_visco_elastiques/Loi_maxwell2D_D.h index 9e91236..bd47bf5 100644 --- a/comportement/lois_visco_elastiques/Loi_maxwell2D_D.h +++ b/comportement/lois_visco_elastiques/Loi_maxwell2D_D.h @@ -119,11 +119,11 @@ class Loi_maxwell2D_D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -177,13 +177,13 @@ class Loi_maxwell2D_D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/lois_visco_elastiques/Loi_maxwell3D.cc b/comportement/lois_visco_elastiques/Loi_maxwell3D.cc index b85f238..b9c1ae3 100644 --- a/comportement/lois_visco_elastiques/Loi_maxwell3D.cc +++ b/comportement/lois_visco_elastiques/Loi_maxwell3D.cc @@ -832,7 +832,7 @@ double Loi_maxwell3D::Module_young_equivalent(Enum_dure temps,const Deformation // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_maxwell3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_maxwell3D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -903,7 +903,7 @@ void Loi_maxwell3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferen // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_maxwell3D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_maxwell3D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " maxwell3D " << " type_derivee " << type_derive << " seule_deviatorique= " << seule_deviatorique << " "; diff --git a/comportement/lois_visco_elastiques/Loi_maxwell3D.h b/comportement/lois_visco_elastiques/Loi_maxwell3D.h index ab0539d..72aba30 100644 --- a/comportement/lois_visco_elastiques/Loi_maxwell3D.h +++ b/comportement/lois_visco_elastiques/Loi_maxwell3D.h @@ -122,14 +122,14 @@ class Loi_maxwell3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas) + void Lecture_base_info (istream& ent,const int cas) {string toto; ent >> toto >> E >> toto >> nu >> toto >> mu >> toto >> mu_p; E_t=E; nu_t = nu; mu_t=mu; mu_p_t=mu_p; }; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas) + void Ecriture_base_info(ostream& sort,const int cas) {sort << "\n E= "<< E <<" nu= "<< nu << " mu= " << mu << " mu_p= "<< mu_p << " "; @@ -189,13 +189,13 @@ class Loi_maxwell3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/lois_visco_elastiques/Loi_newton1D.cc b/comportement/lois_visco_elastiques/Loi_newton1D.cc index 685b67a..a9022d1 100644 --- a/comportement/lois_visco_elastiques/Loi_newton1D.cc +++ b/comportement/lois_visco_elastiques/Loi_newton1D.cc @@ -246,7 +246,7 @@ int Loi_newton1D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_newton1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_newton1D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -281,7 +281,7 @@ void Loi_newton1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferenc // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_newton1D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_newton1D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " NEWTON1D " ; sort << "\n viscosite "; diff --git a/comportement/lois_visco_elastiques/Loi_newton1D.h b/comportement/lois_visco_elastiques/Loi_newton1D.h index a79af87..2e43714 100644 --- a/comportement/lois_visco_elastiques/Loi_newton1D.h +++ b/comportement/lois_visco_elastiques/Loi_newton1D.h @@ -102,12 +102,12 @@ class Loi_newton1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/lois_visco_elastiques/Loi_newton2D_D.cc b/comportement/lois_visco_elastiques/Loi_newton2D_D.cc index 956323a..85f5fb0 100644 --- a/comportement/lois_visco_elastiques/Loi_newton2D_D.cc +++ b/comportement/lois_visco_elastiques/Loi_newton2D_D.cc @@ -246,7 +246,7 @@ int Loi_newton2D_D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_newton2D_D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_newton2D_D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -281,7 +281,7 @@ void Loi_newton2D_D::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefere // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_newton2D_D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_newton2D_D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " NEWTON2D_D " ; sort << "\n viscosite "; diff --git a/comportement/lois_visco_elastiques/Loi_newton2D_D.h b/comportement/lois_visco_elastiques/Loi_newton2D_D.h index 49f242b..dc442a8 100644 --- a/comportement/lois_visco_elastiques/Loi_newton2D_D.h +++ b/comportement/lois_visco_elastiques/Loi_newton2D_D.h @@ -103,12 +103,12 @@ class Loi_newton2D_D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/lois_visco_elastiques/Loi_newton3D.cc b/comportement/lois_visco_elastiques/Loi_newton3D.cc index 07d0702..876c154 100644 --- a/comportement/lois_visco_elastiques/Loi_newton3D.cc +++ b/comportement/lois_visco_elastiques/Loi_newton3D.cc @@ -250,7 +250,7 @@ int Loi_newton3D::TestComplet() // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Loi_newton3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Loi_newton3D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string nom; if (cas == 1) @@ -285,7 +285,7 @@ void Loi_newton3D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferenc // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Loi_newton3D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Loi_newton3D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " NEWTON3D " ; sort << "\n viscosite "; diff --git a/comportement/lois_visco_elastiques/Loi_newton3D.h b/comportement/lois_visco_elastiques/Loi_newton3D.h index 5e18703..0040ac6 100644 --- a/comportement/lois_visco_elastiques/Loi_newton3D.h +++ b/comportement/lois_visco_elastiques/Loi_newton3D.h @@ -102,12 +102,12 @@ class Loi_newton3D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // calcul d'un module d'young équivalent à la loi, ceci pour un // chargement nul diff --git a/comportement/plasticite/Prandtl_Reuss.cc b/comportement/plasticite/Prandtl_Reuss.cc index 4a2160d..bdc217b 100755 --- a/comportement/plasticite/Prandtl_Reuss.cc +++ b/comportement/plasticite/Prandtl_Reuss.cc @@ -64,7 +64,7 @@ Loi_comp_abstraite::SaveResul & // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Prandtl_Reuss::SaveResulPrandtl_Reuss::Lecture_base_info - (ifstream& ent,const int ) + (istream& ent,const int ) { // ici toutes les données sont toujours a priori variables string toto; ent >> toto >> epsilon_barre_t; @@ -76,7 +76,7 @@ void Prandtl_Reuss::SaveResulPrandtl_Reuss::Lecture_base_info // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) void Prandtl_Reuss::SaveResulPrandtl_Reuss::Ecriture_base_info - (ofstream& sort,const int ) + (ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables sort << " epsb_t " << epsilon_barre_t << " " ; sort << " def_plasBB_t " << def_plasBB_t << " "; @@ -812,7 +812,7 @@ void Prandtl_Reuss::Calcul_DsigmaHH_tdt (TenseurHH & sigHH_t,TenseurBB& ,DdlElem // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Prandtl_Reuss::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Prandtl_Reuss::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -835,7 +835,7 @@ void Prandtl_Reuss::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferen // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Prandtl_Reuss::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Prandtl_Reuss::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " module_d'young " << E << " nu " << nu ; // la courbe d'écrouissage diff --git a/comportement/plasticite/Prandtl_Reuss.h b/comportement/plasticite/Prandtl_Reuss.h index 02c573a..0158e94 100644 --- a/comportement/plasticite/Prandtl_Reuss.h +++ b/comportement/plasticite/Prandtl_Reuss.h @@ -128,11 +128,11 @@ class Prandtl_Reuss : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -202,13 +202,13 @@ class Prandtl_Reuss : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); protected : diff --git a/comportement/plasticite/Prandtl_Reuss1D.cc b/comportement/plasticite/Prandtl_Reuss1D.cc index 047e79b..2f0c1f0 100755 --- a/comportement/plasticite/Prandtl_Reuss1D.cc +++ b/comportement/plasticite/Prandtl_Reuss1D.cc @@ -63,7 +63,7 @@ Loi_comp_abstraite::SaveResul & // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Prandtl_Reuss1D::SaveResulPrandtl_Reuss1D::Lecture_base_info - (ifstream& ent,const int ) + (istream& ent,const int ) { // ici toutes les données sont toujours a priori variables string toto; ent >> toto >> epsilon_barre_t; @@ -75,7 +75,7 @@ void Prandtl_Reuss1D::SaveResulPrandtl_Reuss1D::Lecture_base_info // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) void Prandtl_Reuss1D::SaveResulPrandtl_Reuss1D::Ecriture_base_info - (ofstream& sort,const int ) + (ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables sort << " epsb_t " << epsilon_barre_t << " " ; sort << " def_plasBB_t " << def_plasBB_t << " "; @@ -799,7 +799,7 @@ void Prandtl_Reuss1D::Calcul_DsigmaHH_tdt (TenseurHH & sigHH_t,TenseurBB& ,DdlEl // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Prandtl_Reuss1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Prandtl_Reuss1D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -822,7 +822,7 @@ void Prandtl_Reuss1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesRefer // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Prandtl_Reuss1D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Prandtl_Reuss1D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " module_d'young " << E << " nu " << nu ; // la courbe d'écrouissage diff --git a/comportement/plasticite/Prandtl_Reuss1D.h b/comportement/plasticite/Prandtl_Reuss1D.h index a3a3d45..61cdf31 100644 --- a/comportement/plasticite/Prandtl_Reuss1D.h +++ b/comportement/plasticite/Prandtl_Reuss1D.h @@ -116,11 +116,11 @@ class Prandtl_Reuss1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -194,13 +194,13 @@ class Prandtl_Reuss1D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/plasticite/Prandtl_Reuss2D_D.cc b/comportement/plasticite/Prandtl_Reuss2D_D.cc index ba827d0..dba2bbc 100755 --- a/comportement/plasticite/Prandtl_Reuss2D_D.cc +++ b/comportement/plasticite/Prandtl_Reuss2D_D.cc @@ -64,7 +64,7 @@ Loi_comp_abstraite::SaveResul & // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Prandtl_Reuss2D_D::SaveResulPrandtl_Reuss2D_D::Lecture_base_info - (ifstream& ent,const int ) + (istream& ent,const int ) { // ici toutes les données sont toujours a priori variables string toto; ent >> toto >> epsilon_barre_t; @@ -76,7 +76,7 @@ void Prandtl_Reuss2D_D::SaveResulPrandtl_Reuss2D_D::Lecture_base_info // = 2 : on sauvegarde uniquement les données variables //(supposées comme telles) void Prandtl_Reuss2D_D::SaveResulPrandtl_Reuss2D_D::Ecriture_base_info - (ofstream& sort,const int ) + (ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables sort << " epsb_t " << epsilon_barre_t << " " ; sort << " def_plasBB_t " << def_plasBB_t << " "; @@ -652,7 +652,7 @@ void Prandtl_Reuss2D_D::Calcul_DsigmaHH_tdt (TenseurHH & sigHH_t,TenseurBB& ,Ddl // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Prandtl_Reuss2D_D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D +void Prandtl_Reuss2D_D::Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD) { string toto; if (cas == 1) @@ -675,7 +675,7 @@ void Prandtl_Reuss2D_D::Lecture_base_info_loi(ifstream& ent,const int cas,LesRef // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Prandtl_Reuss2D_D::Ecriture_base_info_loi(ofstream& sort,const int cas) +void Prandtl_Reuss2D_D::Ecriture_base_info_loi(ostream& sort,const int cas) { if (cas == 1) { sort << " module_d'young " << E << " nu " << nu ; // la courbe d'écrouissage diff --git a/comportement/plasticite/Prandtl_Reuss2D_D.h b/comportement/plasticite/Prandtl_Reuss2D_D.h index a3701b2..c9c83c3 100644 --- a/comportement/plasticite/Prandtl_Reuss2D_D.h +++ b/comportement/plasticite/Prandtl_Reuss2D_D.h @@ -116,11 +116,11 @@ class Prandtl_Reuss2D_D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -188,13 +188,13 @@ class Prandtl_Reuss2D_D : public Loi_comp_abstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D + void Lecture_base_info_loi(istream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D ,LesFonctions_nD& lesFonctionsnD); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info_loi(ofstream& sort,const int cas); + void Ecriture_base_info_loi(ostream& sort,const int cas); // affichage et definition interactive des commandes particulières à chaques lois void Info_commande_LoisDeComp(UtilLecture& lec); diff --git a/comportement/thermique/Loi_de_Tait.cc b/comportement/thermique/Loi_de_Tait.cc index 97ffc2b..a93f354 100644 --- a/comportement/thermique/Loi_de_Tait.cc +++ b/comportement/thermique/Loi_de_Tait.cc @@ -113,7 +113,7 @@ CompThermoPhysiqueAbstraite::SaveResul & // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Loi_de_Tait::SaveResul_Loi_de_Tait::Lecture_base_info - (ifstream& ent,const int cas) + (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -156,7 +156,7 @@ void Loi_de_Tait::SaveResul_Loi_de_Tait::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Loi_de_Tait::SaveResul_Loi_de_Tait::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n S_R_LoiTait "; @@ -182,7 +182,7 @@ void Loi_de_Tait::SaveResul_Loi_de_Tait::Affiche() { cout << " cristalinite : "; saveCrista->Affiche();}; }; // idem sur un ofstream -void Loi_de_Tait::SaveResul_Loi_de_Tait::Affiche(ofstream& sort) +void Loi_de_Tait::SaveResul_Loi_de_Tait::Affiche(ostream& sort) { sort << "\n S_R_LoiTait "; if (stockParaInt != NULL) { sort << " pression= " << stockParaInt->pression @@ -645,7 +645,7 @@ void Loi_de_Tait::ListeGrandeurs_particulieres(bool absolue,List_io& tab_coor ,const CompThermoPhysiqueAbstraite* loi) {return NULL;}; - // idem sur un ofstream - void Affiche(ofstream& sort); + // idem sur un ostream + void Affiche(ostream& sort); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -198,7 +198,7 @@ class Loi_de_Tait : public CompThermoPhysiqueAbstraite // affichage des donnees particulieres a l'elements // de matiere traite ( c-a-dire au pt calcule) - virtual void AfficheDataSpecif(ofstream& sort,SaveResul * a) const + virtual void AfficheDataSpecif(ostream& sort,SaveResul * a) const { ((SaveResul_Loi_de_Tait*) a)->Affiche(sort);}; diff --git a/comportement/thermique/Loi_iso_thermo.cc b/comportement/thermique/Loi_iso_thermo.cc index 7f33fd7..102ef45 100644 --- a/comportement/thermique/Loi_iso_thermo.cc +++ b/comportement/thermique/Loi_iso_thermo.cc @@ -114,7 +114,7 @@ CompThermoPhysiqueAbstraite::SaveResul & // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) void Loi_iso_thermo::SaveResul_Loi_iso_thermo::Lecture_base_info - (ifstream& ent,const int cas) + (istream& ent,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas string toto; ent >> toto; @@ -160,7 +160,7 @@ void Loi_iso_thermo::SaveResul_Loi_iso_thermo::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Loi_iso_thermo::SaveResul_Loi_iso_thermo::Ecriture_base_info - (ofstream& sort,const int cas) + (ostream& sort,const int cas) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas sort << "\n S_R_LoiIso_thermo "; @@ -185,8 +185,8 @@ void Loi_iso_thermo::SaveResul_Loi_iso_thermo::Affiche() if (saveCrista != NULL) { cout << " cristalinite a tdt: "; saveCrista->Affiche();}; }; -// idem sur un ofstream -void Loi_iso_thermo::SaveResul_Loi_iso_thermo::Affiche(ofstream& sort) +// idem sur un ostream +void Loi_iso_thermo::SaveResul_Loi_iso_thermo::Affiche(ostream& sort) { sort << "\n S_R_LoiIso_thermo "; if (stockParaInt != NULL) { sort << " pression= " << stockParaInt->pression @@ -701,7 +701,7 @@ void Loi_iso_thermo::ListeGrandeurs_particulieres(bool absolue,List_io> toto; @@ -79,7 +79,7 @@ void Hoffman2::SaveCrista_Hoffman2::Lecture_base_info // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) void Hoffman2::SaveCrista_Hoffman2::Ecriture_base_info - (ofstream& sort,const int ) + (ostream& sort,const int ) { // ici toutes les données sont toujours a priori variables // ou en tout cas pour les méthodes appelées, elles sont gérées par le paramètre: cas // sort << "\n S_R_Hoffman " << I_Kcinetique_t << " " << I_Kcinetique << " "; @@ -90,8 +90,8 @@ void Hoffman2::SaveCrista_Hoffman2::Ecriture_base_info void Hoffman2::SaveCrista_Hoffman2::Affiche() { cout << "\n S_R_Hoffman I_Kcinetique_t= " << I_Kcinetique_t << " I_Kcinetique= " << I_Kcinetique << " "; }; -// idem sur un ofstream -void Hoffman2::SaveCrista_Hoffman2::Affiche(ofstream& sort) +// idem sur un ostream +void Hoffman2::SaveCrista_Hoffman2::Affiche(ostream& sort) { sort << "\n S_R_Hoffman I_Kcinetique_t= " << I_Kcinetique_t << " I_Kcinetique= " << I_Kcinetique << " "; }; @@ -344,7 +344,7 @@ double Hoffman2::Cristalinite(CristaliniteAbstraite::SaveCrista * save_donTP // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) -void Hoffman2::Lecture_don_base_info(ifstream& ent,const int cas ,LesCourbes1D& ,LesFonctions_nD& ) +void Hoffman2::Lecture_don_base_info(istream& ent,const int cas ,LesCourbes1D& ,LesFonctions_nD& ) { // ici on ne lit que dans le cas = 1 if (cas == 1) { string nom; @@ -364,7 +364,7 @@ void Hoffman2::Lecture_don_base_info(ifstream& ent,const int cas ,LesCourbes1D& // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) -void Hoffman2::Ecriture_don_base_info(ofstream& sort ,const int cas) const +void Hoffman2::Ecriture_don_base_info(ostream& sort ,const int cas) const { // ici on ne sauvegarde que dans le cas = 1 if (cas == 1) { sort << "\n Cristallinite_Hoffman2 " diff --git a/comportement/thermique/Taux_crista/Hoffman2.h b/comportement/thermique/Taux_crista/Hoffman2.h index 4174f39..8d4be2f 100644 --- a/comportement/thermique/Taux_crista/Hoffman2.h +++ b/comportement/thermique/Taux_crista/Hoffman2.h @@ -121,16 +121,16 @@ class Hoffman2 : public CristaliniteAbstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_base_info (ifstream& ent,const int cas); + void Lecture_base_info (istream& ent,const int cas); // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_base_info(ofstream& sort,const int cas); + void Ecriture_base_info(ostream& sort,const int cas); // affichage des infos void Affiche(); - // idem sur un ofstream - void Affiche(ofstream& sort); + // idem sur un ostream + void Affiche(ostream& sort); // mise à jour des informations transitoires en définitif s'il y a convergence // par exemple (pour la plasticité par exemple) @@ -177,11 +177,11 @@ class Hoffman2 : public CristaliniteAbstraite // cas donne le niveau de la récupération // = 1 : on récupère tout // = 2 : on récupère uniquement les données variables (supposées comme telles) - void Lecture_don_base_info(ifstream& ,const int cas ,LesCourbes1D& ,LesFonctions_nD&) ; + void Lecture_don_base_info(istream& ,const int cas ,LesCourbes1D& ,LesFonctions_nD&) ; // cas donne le niveau de sauvegarde // = 1 : on sauvegarde tout // = 2 : on sauvegarde uniquement les données variables (supposées comme telles) - void Ecriture_don_base_info(ofstream& sort,const int cas) const ; + void Ecriture_don_base_info(ostream& sort,const int cas) const ; private : // VARIABLES PROTEGEES : diff --git a/contact/ElContact.cc b/contact/ElContact.cc index 19e3980..bd24ddc 100644 --- a/contact/ElContact.cc +++ b/contact/ElContact.cc @@ -2435,7 +2435,7 @@ void ElContact::TversTdt() //----- lecture écriture base info ----- // lecture base info -void ElContact::Lec_base_info_ElContact(ifstream& ent) +void ElContact::Lec_base_info_ElContact(istream& ent) { // tout d'abord les données propres à l'élément string toto; ////debug @@ -2481,7 +2481,7 @@ void ElContact::Lec_base_info_ElContact(ifstream& ent) // donc on sauvegarde toujours tout // on ne sauvegarde que ce qui est particulier à l'élément (en particulier ce qui est relatif au noeud esclave et à l'éléments finis // n'est évidemment pas sauvegardé ici) -void ElContact::Ecri_base_info_ElContact(ofstream& sort) +void ElContact::Ecri_base_info_ElContact(ostream& sort) { // écriture du type sort << "\n Elcontact: "; // les aspects liés au traitement du contact diff --git a/contact/ElContact.h b/contact/ElContact.h index 1e0cbd6..8671e89 100644 --- a/contact/ElContact.h +++ b/contact/ElContact.h @@ -403,8 +403,8 @@ class ElContact void TversTdt(); //----- lecture écriture de restart ----- - void Lec_base_info_ElContact(ifstream& ent); - void Ecri_base_info_ElContact(ofstream& sort); + void Lec_base_info_ElContact(istream& ent); + void Ecri_base_info_ElContact(ostream& sort); #ifdef UTILISATION_MPI // spécifique au calcul parallèle // ----- pour l'instant ne sert pas !!! on commente ------ diff --git a/contact/LesContacts.cc b/contact/LesContacts.cc index d3f3ee4..dc47d8f 100644 --- a/contact/LesContacts.cc +++ b/contact/LesContacts.cc @@ -2788,7 +2788,7 @@ void LesContacts::CalculReaction(Vecteur& residu,bool& decol,const Nb_assemb& ca // affichage des reactions de contact sur la sortie // il s'agit ici d'une sortie sur fichier : seule le cpu 0 l'effectue -void LesContacts::Affiche(ofstream& sort) const +void LesContacts::Affiche(ostream& sort) const { #ifdef UTILISATION_MPI int proc_en_cours = ParaGlob::Monde()->rank(); diff --git a/contact/LesContacts.h b/contact/LesContacts.h index 4e1cb44..549b1e3 100644 --- a/contact/LesContacts.h +++ b/contact/LesContacts.h @@ -250,7 +250,7 @@ class LesContacts // affichage des reactions de contact sur la sortie - void Affiche(ofstream& sort) const ; + void Affiche(ostream& sort) const ; // affichage à l'écran des informations liées au contact void Affiche() const ; @@ -298,11 +298,11 @@ class LesContacts //----- lecture écriture de restart ----- // cas donne le niveau de sauvegarde - void Ecri_base_info_LesContacts(ofstream& sort); + void Ecri_base_info_LesContacts(ostream& sort); // on utilise deux pointeurs de fonctions qui permettent de récupérer le pointeur de noeud esclave // idem au niveau de l'élément template - void Lec_base_info_LesContacts(ifstream& ent + void Lec_base_info_LesContacts(istream& ent ,T& instance // l'instance qui permet d'appeler les pointeurs de fonctions ,Noeud& (T::*RecupNoeud)(int i, int j) const ,Element& (T::*RecupElement_LesMaille) (int i, int j) const); diff --git a/contact/LesContacts_2.cc b/contact/LesContacts_2.cc index 050184f..f7cb175 100755 --- a/contact/LesContacts_2.cc +++ b/contact/LesContacts_2.cc @@ -43,7 +43,7 @@ // on utilise deux pointeurs de fonctions qui permettent de récupérer le pointeur de noeud esclave // idem au niveau de l'élément template -void LesContacts::Lec_base_info_LesContacts(ifstream& ent +void LesContacts::Lec_base_info_LesContacts(istream& ent ,T& instance // l'instance qui permet d'appeler les pointeurs de fonctions ,Noeud& (T::*RecupNoeud)(int i, int j) const ,Element& (T::*RecupElement_LesMaille)(int i, int j) const) diff --git a/contact/LesContacts_3.cc b/contact/LesContacts_3.cc index 6eb9a98..fbbe1cf 100755 --- a/contact/LesContacts_3.cc +++ b/contact/LesContacts_3.cc @@ -224,7 +224,7 @@ double LesContacts::Pas_de_temps_ideal() // écriture base info // cas donne le niveau de sauvegarde -void LesContacts::Ecri_base_info_LesContacts(ofstream& sort) +void LesContacts::Ecri_base_info_LesContacts(ostream& sort) { // globalement on sauvegarde toujours tout, car les éléments de contact peuvent apparaître à tout moment // tout d'abord on indique le type sort << "\n LesContacts: taille " << listContact.size() << " " ; diff --git a/tenseurs_mai99/Coordonnees/Coordonnee.cc b/tenseurs_mai99/Coordonnees/Coordonnee.cc index 0996c12..f206172 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee.cc +++ b/tenseurs_mai99/Coordonnees/Coordonnee.cc @@ -972,7 +972,7 @@ void Coordonnee::Ajout_meme_valeur(double val) inline #endif // sortie du schemaXML: en fonction de enu -void Coordonnee::SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) +void Coordonnee::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/tenseurs_mai99/Coordonnees/Coordonnee.h b/tenseurs_mai99/Coordonnees/Coordonnee.h index 2b18387..db7f89c 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee.h +++ b/tenseurs_mai99/Coordonnees/Coordonnee.h @@ -279,7 +279,7 @@ class Coordonnee /// calcul la norme euclidienne au carré double Carre()const {return (*this) * (*this);}; /// sortie du schemaXML: en fonction de enu - static void SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) ; + static void SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) ; // changement de base // beta(i,j) represente les coordonnees de la nouvelle base gp dans l'ancienne g // gp(i) = beta(i,j) * g(j) @@ -492,7 +492,7 @@ class CoordonneeH /// ajoute une même valeur à tous les coordonnées void Ajout_meme_valeur(double val); /// sortie du schemaXML: en fonction de enu - static void SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) ; + static void SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) ; // changement de base // beta(i,j) represente les coordonnees de la nouvelle base gpB dans l'ancienne gB // gpB(i) = beta(i,j) * gB(j) @@ -686,7 +686,7 @@ class CoordonneeB /// ajoute une même valeur à tous les coordonnées void Ajout_meme_valeur(double val); /// sortie du schemaXML: en fonction de enu - static void SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) ; + static void SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) ; // changement de base // beta(i,j) represente les coordonnees de la nouvelle base duale gpH dans l'ancienne gH // gpH(i) = beta(i,j) * gH(j), i indice de ligne, j indice de colonne diff --git a/tenseurs_mai99/Coordonnees/Coordonnee1.cc b/tenseurs_mai99/Coordonnees/Coordonnee1.cc index 5d5b4f4..fb1b7c3 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee1.cc +++ b/tenseurs_mai99/Coordonnees/Coordonnee1.cc @@ -333,7 +333,7 @@ double Coordonnee1::Somme() const inline #endif // sortie du schemaXML: en fonction de enu -void Coordonnee1::SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) +void Coordonnee1::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/tenseurs_mai99/Coordonnees/Coordonnee1.h b/tenseurs_mai99/Coordonnees/Coordonnee1.h index 3c1b104..cbe5f0b 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee1.h +++ b/tenseurs_mai99/Coordonnees/Coordonnee1.h @@ -201,7 +201,7 @@ class Coordonnee1 : public Coordonnee /// somme de tous les composantes double Somme() const ; /// sortie du schemaXML: en fonction de enu - static void SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) ; + static void SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) ; protected : @@ -346,7 +346,7 @@ class Coordonnee1H : public CoordonneeH /// somme de tous les composantes double Somme() const ; /// sortie du schemaXML: en fonction de enu - static void SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) ; + static void SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) ; protected : @@ -489,7 +489,7 @@ class Coordonnee1B : public CoordonneeB /// somme de tous les composantes double Somme() const ; /// sortie du schemaXML: en fonction de enu - static void SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) ; + static void SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) ; protected : diff --git a/tenseurs_mai99/Coordonnees/Coordonnee1B.cc b/tenseurs_mai99/Coordonnees/Coordonnee1B.cc index 6aa1439..f2e01a9 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee1B.cc +++ b/tenseurs_mai99/Coordonnees/Coordonnee1B.cc @@ -343,7 +343,7 @@ double Coordonnee1B::Somme() const inline #endif // sortie du schemaXML: en fonction de enu -void Coordonnee1B::SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) +void Coordonnee1B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : diff --git a/tenseurs_mai99/Coordonnees/Coordonnee1H.cc b/tenseurs_mai99/Coordonnees/Coordonnee1H.cc index 42ba6c8..57ac715 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee1H.cc +++ b/tenseurs_mai99/Coordonnees/Coordonnee1H.cc @@ -342,7 +342,7 @@ double Coordonnee1H::Somme() const inline #endif // sortie du schemaXML: en fonction de enu -void Coordonnee1H::SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) +void Coordonnee1H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { switch (enu) { case XML_TYPE_GLOBAUX : @@ -373,7 +373,7 @@ void Coordonnee1H::SchemaXML_Coordonnee(ofstream& sort,const Enum_IO_XML enu) } default: cout << "\n *** attention cas non pris en compte pour le moment " << " XML_TYPE_GLOBAUX= "<