From c96a7b25b08cf9615eb78715b4e2d94f22455c3a Mon Sep 17 00:00:00 2001 From: luz paz Date: Fri, 22 Jul 2022 20:17:29 -0400 Subject: [PATCH 1/2] Fix typos These are follow-up to 6d587da1 --- Solver/src/addons/tools/FWHPreSurface.f90 | 14 +++++----- .../src/addons/tools/LocalRefinementClass.f90 | 6 ++--- Solver/src/addons/tools/SurfaceClass.f90 | 26 +++++++++---------- .../WallFunctionConnectivity.f90 | 4 +-- Solver/src/libs/mesh/IBMClass.f90 | 10 +++---- Solver/src/libs/mesh/KDClass.f90 | 2 +- Solver/src/libs/mesh/SurfaceMesh.f90 | 8 +++--- Solver/src/libs/mesh/ZoneClass.f90 | 8 +++--- Solver/src/libs/monitors/FWHGeneralClass.f90 | 2 +- Solver/src/libs/monitors/FWHObseverClass.f90 | 2 +- .../common/WallFunctionDefinitions.f90 | 6 ++--- .../physics/spallartalmaras/Turbulence.f90 | 18 ++++++------- Solver/src/libs/sources/TripForceClass.f90 | 22 ++++++++-------- .../timeintegrator/AnalyticalJacobian.f90 | 2 +- 14 files changed, 65 insertions(+), 65 deletions(-) diff --git a/Solver/src/addons/tools/FWHPreSurface.f90 b/Solver/src/addons/tools/FWHPreSurface.f90 index d6c959543..bc3aec18d 100644 --- a/Solver/src/addons/tools/FWHPreSurface.f90 +++ b/Solver/src/addons/tools/FWHPreSurface.f90 @@ -182,7 +182,7 @@ Subroutine extractSurface(mesh, controlVariables) globaleIDs, useFilter) numberOfElements = size(eIDs) -! get the firs faces ids and construct the faces +! get the first faces ids and construct the faces ! ---------------------------------------------- allocate(firstFIDs(numberOfElements)) allocate(firstFaces(numberOfElements)) @@ -707,7 +707,7 @@ End Subroutine getFirstFace ! !//////////////////////////////////////////////////////////////////////// ! - Subroutine getAdditionalElements(mesh, BCeID, numberOfElements, zoneMarkers, zN, newEIDs, realNumberOfElemts) + Subroutine getAdditionalElements(mesh, BCeID, numberOfElements, zoneMarkers, zN, newEIDs, realNumberOfElements) use ElementConnectivityDefinitions, only: normalAxis, FACES_PER_ELEMENT use ElementClass @@ -717,7 +717,7 @@ Subroutine getAdditionalElements(mesh, BCeID, numberOfElements, zoneMarkers, zN, integer, intent(in) :: BCeID, numberOfElements, zN integer, dimension(zN), intent(in) :: zoneMarkers integer, dimension(:), allocatable, intent(out) :: newEIDs - integer, intent(out) :: realNumberOfElemts + integer, intent(out) :: realNumberOfElements ! local variables integer :: i, j, neID, zoneID @@ -725,7 +725,7 @@ Subroutine getAdditionalElements(mesh, BCeID, numberOfElements, zoneMarkers, zN, integer :: thisMarker, fBCindex, conIndex, conNormal integer, dimension(:), allocatable :: nEs - realNumberOfElemts = 0 + realNumberOfElements = 0 BCe => mesh%elements(BCeID) zone_loop: do i = 1, zN @@ -745,7 +745,7 @@ Subroutine getAdditionalElements(mesh, BCeID, numberOfElements, zoneMarkers, zN, i=1 do i = 1, numberOfElements nEs(i) = e%eID - realNumberOfElemts = realNumberOfElemts + 1 + realNumberOfElements = realNumberOfElements + 1 conNormal = normalAxis(fBCindex) * (-1) ! conIndex = findloc(normalAxis, conNormal, dim=1) conIndex = maxloc(merge(1.0, 0.0, normalAxis == conNormal), dim=1) @@ -756,8 +756,8 @@ Subroutine getAdditionalElements(mesh, BCeID, numberOfElements, zoneMarkers, zN, !todo check that new bc have been reached - allocate(newEIDs(realNumberOfElemts)) - newEIDs = nEs(1:realNumberOfElemts) + allocate(newEIDs(realNumberOfElements)) + newEIDs = nEs(1:realNumberOfElements) deallocate(nEs) diff --git a/Solver/src/addons/tools/LocalRefinementClass.f90 b/Solver/src/addons/tools/LocalRefinementClass.f90 index 7fc78a1ed..44e604d93 100644 --- a/Solver/src/addons/tools/LocalRefinementClass.f90 +++ b/Solver/src/addons/tools/LocalRefinementClass.f90 @@ -23,11 +23,11 @@ Module LocalRefinement ! real(kind=RP), dimension(:,:), allocatable :: xlim ! limits for refinement in x direction real(kind=RP), dimension(:,:), allocatable :: ylim real(kind=RP), dimension(:,:), allocatable :: zlim - integer, dimension(:), allocatable :: Nx ! polynomial order for each selection whithin the limits in x diredirection + integer, dimension(:), allocatable :: Nx ! polynomial order for each selection within the limits in x redirection integer, dimension(:), allocatable :: Ny integer, dimension(:), allocatable :: Nz integer, dimension(3) :: globalNxyz ! default polynomial order, outside the limits - integer :: lenRegions ! number of regions, it has to be the same for each diredirection + integer :: lenRegions ! number of regions, it has to be the same for each redirection contains procedure :: Construct => LocalRef_Construct @@ -54,7 +54,7 @@ Subroutine LocalRef_Construct(self, controlVariables) integer, allocatable :: Nx(:), Ny(:), Nz(:) !temporal variables for getting the default pol orders integer :: Nmax - !get polynomial orders for all regions in all diredirections + !get polynomial orders for all regions in all redirections NxName = trim(controlVariables%stringValueForKey("x regions orders",LINE_LENGTH)) NyName = trim(controlVariables%stringValueForKey("y regions orders",LINE_LENGTH)) NzName = trim(controlVariables%stringValueForKey("z regions orders",LINE_LENGTH)) diff --git a/Solver/src/addons/tools/SurfaceClass.f90 b/Solver/src/addons/tools/SurfaceClass.f90 index 3087aefba..9cd9bf59c 100644 --- a/Solver/src/addons/tools/SurfaceClass.f90 +++ b/Solver/src/addons/tools/SurfaceClass.f90 @@ -118,7 +118,7 @@ Subroutine SurfaceConstruct(self, mesh, fileName, eIDs, gIDs, fIDs, N) self % name = RemovePath(getFileName(fileName)) allocate(self % surfaceZone) - call self % surfaceZone % CreateFicticious(-1, self % name, totalN, fIDs) + call self % surfaceZone % CreateFictitious(-1, self % name, totalN, fIDs) allocate( self % globaleIDs(totalN), self % fIDs(totalN) ) self % globaleIDs = gIDs @@ -781,7 +781,7 @@ Subroutine ElementGetNotConnectedN(self, mesh, surfaceElements, N, newFaceID) integer :: i, j, k, numE, eID, targetEID, edgeIndex, targertEfID, faceIndex, normalFace integer, dimension(2) :: thisFaceIndexes class(SurfaceFace_t), pointer :: surfaceFace - integer, dimension(:), allocatable :: allElements, connectedElements, posibleElements + integer, dimension(:), allocatable :: allElements, connectedElements, possibleElements if ( .not. self % needSecondFace ) return newFaceID = 0 @@ -854,7 +854,7 @@ Subroutine ElementGetNotConnectedN(self, mesh, surfaceElements, N, newFaceID) deallocate(allElements) ! get the element that is not connected to the already found surface - ! first get the elements whith non shared edges + ! first get the elements with non shared edges allocate(allElements(numE)) targetEID = 0 i = 0 @@ -873,12 +873,12 @@ Subroutine ElementGetNotConnectedN(self, mesh, surfaceElements, N, newFaceID) targetEID = allElements(1) deallocate(allElements) else - allocate(posibleElements(numE)) - posibleElements = allElements(1:numE) + allocate(possibleElements(numE)) + possibleElements = allElements(1:numE) deallocate(allElements) i = 0 pos_elems_loop: do k = 1, numE - eID = posibleElements(k) + eID = possibleElements(k) do j = 1, NUM_OF_NEIGHBORS if (surfaceFace % shareCorner(surfaceElements(eID) % faces(j))) cycle pos_elems_loop end do @@ -936,7 +936,7 @@ Subroutine ElementReconstructPeriodic(self) class(SurfaceElement_t), target :: self !local variables - class(SurfaceFace_t), pointer :: faceNew=>null(), faceOposite=>null() + class(SurfaceFace_t), pointer :: faceNew=>null(), faceOpposite=>null() integer :: faceConnections real(kind=RP), dimension(:,:), allocatable :: allCorners real(kind=RP), dimension(NDIM,FACES_PER_ELEMENT) :: newCorners, notChangeCorners, oldCorners @@ -956,7 +956,7 @@ Subroutine ElementReconstructPeriodic(self) faceNew => self % faces(i) cycle faces_loop elseif (faceConnections .eq. FACES_PER_ELEMENT-2) then - faceOposite => self % faces(i) + faceOpposite => self % faces(i) cycle faces_loop end if end do faces_loop @@ -975,12 +975,12 @@ Subroutine ElementReconstructPeriodic(self) allCorners(:,(i-1)*NODES_PER_FACE+j) = self % faces(i) % edges(j) % corners(:,1) end do end do - ! get new and oposite corners + ! get new and opposite corners do j = 1, NODES_PER_FACE newCorners(:,j) = faceNew % edges(j) % corners(:,1) - notChangeCorners(:,j) = faceOposite % edges(j) % corners(:,1) + notChangeCorners(:,j) = faceOpposite % edges(j) % corners(:,1) end do - ! get old corners, the ones that are not new nor oposite corners, remove duplicated + ! get old corners, the ones that are not new nor opposite corners, remove duplicated k = 0 outer: do i = 1, size(allCorners(1,:)) if (k .ge. NODES_PER_FACE) exit outer @@ -1007,11 +1007,11 @@ Subroutine ElementReconstructPeriodic(self) do i = 1, FACES_PER_ELEMENT if (associated(faceNew, target=self % faces(i))) cycle - if (associated(faceOposite, target=self % faces(i))) cycle + if (associated(faceOpposite, target=self % faces(i))) cycle call self % faces(i) % reconstructPeriod(oldCorners, newCorners, oldNewCornersMap) end do - nullify(faceNew, faceOposite) + nullify(faceNew, faceOpposite) End Subroutine ElementReconstructPeriodic ! diff --git a/Solver/src/libs/discretization/WallFunctionConnectivity.f90 b/Solver/src/libs/discretization/WallFunctionConnectivity.f90 index a6ce6628f..7f68d66a0 100644 --- a/Solver/src/libs/discretization/WallFunctionConnectivity.f90 +++ b/Solver/src/libs/discretization/WallFunctionConnectivity.f90 @@ -57,7 +57,7 @@ Subroutine Initialize_WallConnection(controlVariables, mesh) use FileReadingUtilities, only: getCharArrayFromString use ElementConnectivityDefinitions, only: normalAxis, FACES_PER_ELEMENT use MPI_Process_Info - use WallFunctionDefinitions, only: Initialize_Wall_Fuction, wallFuncIndex, STD_WALL, ABL_WALL, u_tau0, useAverageV + use WallFunctionDefinitions, only: Initialize_Wall_Function, wallFuncIndex, STD_WALL, ABL_WALL, u_tau0, useAverageV use Headers #ifdef _HAS_MPI_ use mpi @@ -77,7 +77,7 @@ Subroutine Initialize_WallConnection(controlVariables, mesh) integer :: actualElementID, linkedElementID, normalIndex, oppositeIndex, oppositeNormalIndex integer :: allFaces, ierr - call Initialize_Wall_Fuction(controlVariables, useWallFunc) + call Initialize_Wall_Function(controlVariables, useWallFunc) if (.not. useWallFunc) then return end if diff --git a/Solver/src/libs/mesh/IBMClass.f90 b/Solver/src/libs/mesh/IBMClass.f90 index a3bf0825d..eadabf7cb 100644 --- a/Solver/src/libs/mesh/IBMClass.f90 +++ b/Solver/src/libs/mesh/IBMClass.f90 @@ -1986,7 +1986,7 @@ end function isPointInsideTri ! This function computes the minimum distance from a point to a triangle in 3D. ! for more ditails see https://www.geometrictools.com/Documentation/DistancePoint3Triangle3.pdf ! ------------------------------------------------ - subroutine MinumumPointTriDistance( Point, TriangleVertex1, TriangleVertex2, & + subroutine MinimumPointTriDistance( Point, TriangleVertex1, TriangleVertex2, & TriangleVertex3, dist, IntersectionPoint ) use MappedGeometryClass implicit none @@ -2031,7 +2031,7 @@ subroutine MinumumPointTriDistance( Point, TriangleVertex1, TriangleVertex2, & IntersectionPoint = bb + s*E0 + t*E1 - end subroutine MinumumPointTriDistance + end subroutine MinimumPointTriDistance ! !///////////////////////////////////////////////////////////////////////////////////////////// ! @@ -2275,7 +2275,7 @@ subroutine MinimumDistance( Point, root, minDist, normal ) do i = 1, tree% NumOfObjs index = tree% ObjsIndeces(i) - call MinumumPointTriDistance( Point, root% ObjectsList(index)% vertices(1)% coords, & + call MinimumPointTriDistance( Point, root% ObjectsList(index)% vertices(1)% coords, & root% ObjectsList(index)% vertices(2)% coords, & root% ObjectsList(index)% vertices(3)% coords, Dist, & IntersPoint ) @@ -2348,7 +2348,7 @@ recursive subroutine MinimumDistOtherBoxes( Point, root, tree, Radius, New_minDi if( tree% isLast ) then do i = 1, tree% NumOfObjs index = tree% ObjsIndeces(i) - call MinumumPointTriDistance( Point, root% ObjectsList(index)% vertices(1)% coords, & + call MinimumPointTriDistance( Point, root% ObjectsList(index)% vertices(1)% coords, & root% ObjectsList(index)% vertices(2)% coords, & root% ObjectsList(index)% vertices(3)% coords, Dist, & IntersPoint ) @@ -2372,7 +2372,7 @@ end subroutine MinimumDistOtherBoxes !///////////////////////////////////////////////////////////////////////////////////////////// ! ! --------------------------------------------------------------------------------------------------- -! This subroutine checks if a the sphere whit radius minDist is inside the box or not. If it's not +! This subroutine checks if a sphere with radius minDist is inside the box or not. If it's not ! a/ circle/s is/are computed. Each circle is the base of a cylinder used to find possible boxes that ! can intersect the sphere. ! --------------------------------------------------------------------------------------------------- diff --git a/Solver/src/libs/mesh/KDClass.f90 b/Solver/src/libs/mesh/KDClass.f90 index 3d21ee649..ae45919fc 100644 --- a/Solver/src/libs/mesh/KDClass.f90 +++ b/Solver/src/libs/mesh/KDClass.f90 @@ -327,7 +327,7 @@ end subroutine KDtree_plotBlock ! ! ------------------------------------------------- ! This subroutine sets up the starting box of the tree which is called root. -! It coincides whit the OBB if PointList not present. +! It coincides with the OBB if PointList not present. ! ------------------------------------------------ subroutine KDtree_SetUpRoot( this, stl, Vertices, PointList ) diff --git a/Solver/src/libs/mesh/SurfaceMesh.f90 b/Solver/src/libs/mesh/SurfaceMesh.f90 index 19936bbef..666c11fa6 100644 --- a/Solver/src/libs/mesh/SurfaceMesh.f90 +++ b/Solver/src/libs/mesh/SurfaceMesh.f90 @@ -1,6 +1,6 @@ !////////////////////////////////////////////////////// ! -!This module handle the ficticious surfaces that will be export to save solution of a set of faces, such as slices and FWH acoustic analogy +!This module handle the fictitious surfaces that will be export to save solution of a set of faces, such as slices and FWH acoustic analogy ! The solution is saved before the first time step and at a fixed dt #include "Includes.h" @@ -28,7 +28,7 @@ Module SurfaceMesh integer :: numberOfSurfaces integer, dimension(:), allocatable :: totalFaces ! number of faces in all partitions for each surface integer, dimension(:), allocatable :: surfaceTypes ! type of each surface - type(Zone_t), dimension(:), allocatable :: zones ! ficticious zones that contains the faces of each surface + type(Zone_t), dimension(:), allocatable :: zones ! fictitious zones that contains the faces of each surface logical, dimension(:), allocatable :: surfaceActive ! flag for each surface character(len=LINE_LENGTH), dimension(:), allocatable :: file_names integer, dimension(:,:), allocatable :: globalFid ! for I/O with mpi @@ -300,7 +300,7 @@ Subroutine SurfConstruct(self, controlVariables, mesh) ! ------------------ if ( .not. MPI_Process % isRoot ) return if (hasFWH .and. .not. (hasBC .or. hasSliceX .or. hasSliceY .or. hasSliceZ)) return - call Subsection_Header("Ficticious surfaces zone") + call Subsection_Header("Fictitious surfaces zone") write(STD_OUT,'(30X,A,A28,I0)') "->", "Number of surfaces: ", self % numberOfSurfaces if (.not. all(self % surfaceActive)) write(STD_OUT,'(30X,A,A28,I0)') "->", "Inactive surfaces: ", count(.not. self % surfaceActive, dim=1) write(STD_OUT,'(30X,A,A28,I0)') "->", "Number of slices: ", idSliceX + idSliceY + idSliceZ @@ -573,7 +573,7 @@ Subroutine createSingleSurface(self, surface_index, surface_type, file_name, zon self % file_names(surface_index) = trim(file_name) ! not set active nor create zone if there are no faces if (no_of_faces .le. 0) return - call self % zones(surface_index) % CreateFicticious(-1, trim(zone_name), no_of_faces, facesIDs) + call self % zones(surface_index) % CreateFictitious(-1, trim(zone_name), no_of_faces, facesIDs) self % surfaceActive(surface_index) = .true. End Subroutine createSingleSurface diff --git a/Solver/src/libs/mesh/ZoneClass.f90 b/Solver/src/libs/mesh/ZoneClass.f90 index e47bdbcb9..4de9e9a53 100644 --- a/Solver/src/libs/mesh/ZoneClass.f90 +++ b/Solver/src/libs/mesh/ZoneClass.f90 @@ -23,7 +23,7 @@ module ZoneClass procedure :: Initialize => Zone_Initialize procedure :: copy => Zone_Assign generic :: assignment(=) => copy - procedure :: CreateFicticious => Zone_CreateFicticious + procedure :: CreateFictitious => Zone_CreateFictitious end type Zone_t contains @@ -226,8 +226,8 @@ elemental subroutine Zone_Assign (to, from) to % faces = from % faces end subroutine Zone_Assign - ! create a ficticious zone, useful to represent ficticious surfaces such as slices or FWH analogy - Subroutine Zone_CreateFicticious(self, marker, zoneName, no_of_faces, facesID) + ! create a fictitious zone, useful to represent fictitious surfaces such as slices or FWH analogy + Subroutine Zone_CreateFictitious(self, marker, zoneName, no_of_faces, facesID) implicit none class(Zone_t) :: self @@ -241,6 +241,6 @@ Subroutine Zone_CreateFicticious(self, marker, zoneName, no_of_faces, facesID) allocate(self % faces(no_of_faces)) self % faces = facesID - End Subroutine Zone_CreateFicticious + End Subroutine Zone_CreateFictitious end module ZoneClass diff --git a/Solver/src/libs/monitors/FWHGeneralClass.f90 b/Solver/src/libs/monitors/FWHGeneralClass.f90 index ea5643309..e004e84c3 100644 --- a/Solver/src/libs/monitors/FWHGeneralClass.f90 +++ b/Solver/src/libs/monitors/FWHGeneralClass.f90 @@ -144,7 +144,7 @@ Subroutine FWHConstruct(self, mesh, controlVariables) ! Describe the zones ! ------------------ if ( .not. MPI_Process % isRoot ) return - call Subsection_Header("Ficticious FWH zone") + call Subsection_Header("Fictitious FWH zone") write(STD_OUT,'(30X,A,A28,I0)') "->", "Number of faces: ", no_of_faces write(STD_OUT,'(30X,A,A28,I0)') "->", "Number of observers: ", self % numberOfObservers write(STD_OUT,'(30X,A,A28,I0)') "->", "Number of integrals: ", self % numberOfObservers * no_of_faces diff --git a/Solver/src/libs/monitors/FWHObseverClass.f90 b/Solver/src/libs/monitors/FWHObseverClass.f90 index 2fa2d0528..eb381a6f3 100644 --- a/Solver/src/libs/monitors/FWHObseverClass.f90 +++ b/Solver/src/libs/monitors/FWHObseverClass.f90 @@ -64,7 +64,7 @@ Module FWHObseverClass ! real(kind=RP), dimension(NDIM) :: x ! position of the observer at global coordinates integer :: numberOfFaces class(ObserverSourcePairClass), dimension(:), allocatable :: sourcePair - real(kind=RP), dimension(:,:), allocatable :: Pac ! acoustic pressure, two componenets and the total (sum) + real(kind=RP), dimension(:,:), allocatable :: Pac ! acoustic pressure, two components and the total (sum) real(kind=RP) :: tDelay real(kind=RP) :: tDelayMax logical :: active diff --git a/Solver/src/libs/physics/common/WallFunctionDefinitions.f90 b/Solver/src/libs/physics/common/WallFunctionDefinitions.f90 index d5f016013..97ea1d9d7 100644 --- a/Solver/src/libs/physics/common/WallFunctionDefinitions.f90 +++ b/Solver/src/libs/physics/common/WallFunctionDefinitions.f90 @@ -30,7 +30,7 @@ Module WallFunctionDefinitions ! ! Public definitions ! ****************** ! - public Initialize_Wall_Fuction + public Initialize_Wall_Function ! integer, parameter :: STD_WALL = 1 integer, parameter :: ABL_WALL = 2 @@ -53,7 +53,7 @@ Module WallFunctionDefinitions ! ! !------------------------------------------------------------------------------------------------------------------------ ! - Subroutine Initialize_Wall_Fuction(controlVariables, correct) + Subroutine Initialize_Wall_Function(controlVariables, correct) use FTValueDictionaryClass implicit none class(FTValueDictionary), intent(in) :: controlVariables @@ -116,7 +116,7 @@ Subroutine Initialize_Wall_Fuction(controlVariables, correct) ! if it arrives here everything has gone well correct = .true. - End Subroutine Initialize_Wall_Fuction + End Subroutine Initialize_Wall_Function ! !------------------------------------------------------------------------------------------------------------------------ ! diff --git a/Solver/src/libs/physics/spallartalmaras/Turbulence.f90 b/Solver/src/libs/physics/spallartalmaras/Turbulence.f90 index 735d31cbe..eb1f210e2 100644 --- a/Solver/src/libs/physics/spallartalmaras/Turbulence.f90 +++ b/Solver/src/libs/physics/spallartalmaras/Turbulence.f90 @@ -157,7 +157,7 @@ subroutine SA_Compute_SourceTerms(self, rhotheta, kinematic_viscocity, rho, dwal real(kind=RP) :: vort, somega real(kind=RP) :: fv1 real(kind=RP) :: production_G - real(kind=RP) :: destruciton_Y + real(kind=RP) :: destruction_Y real(kind=RP) :: source_Kappa real(kind=RP) :: U_x(NDIM) real(kind=RP) :: U_y(NDIM) @@ -173,16 +173,16 @@ subroutine SA_Compute_SourceTerms(self, rhotheta, kinematic_viscocity, rho, dwal if (dwall .GT. 0.0_RP) then call self % Compute_ProductionTerm(chi, fv1, vort, rho, theta, dwall, production_G) - call self % Compute_DestructionTerm(chi, fv1, vort, rho, theta, dwall, destruciton_Y) + call self % Compute_DestructionTerm(chi, fv1, vort, rho, theta, dwall, destruction_Y) else production_G = 0.0_RP - destruciton_Y = 0.0_RP + destruction_Y = 0.0_RP endif call self % Compute_AdditionalSourceTermKappa(rho, Theta_x, Theta_y, Theta_z, source_Kappa) S_SA(1:5) = 0.0_RP - S_SA(6) = production_G - destruciton_Y + source_Kappa + S_SA(6) = production_G - destruction_Y + source_Kappa end subroutine SA_Compute_SourceTerms @@ -292,9 +292,9 @@ function Compute_gn(self, chi) result (gn) end function Compute_gn !///////////////////////////////////////////////////////// -! compute destruciton terms +! compute destruction terms - subroutine Compute_DestructionTerm(self, chi, fv1, vort, rho, theta, dwall, destruciton_Y) + subroutine Compute_DestructionTerm(self, chi, fv1, vort, rho, theta, dwall, destruction_Y) implicit none class(Spalart_Almaras_t), intent(inout) :: self real(kind=RP), intent(in) :: chi @@ -303,7 +303,7 @@ subroutine Compute_DestructionTerm(self, chi, fv1, vort, rho, theta, dwall, dest real(kind=RP), intent(in) :: rho real(kind=RP), intent(in) :: theta real(kind=RP), intent(in) :: dwall - real(kind=RP), intent(inout) :: destruciton_Y + real(kind=RP), intent(inout) :: destruction_Y real(kind=RP) :: g real(kind=RP) :: fw @@ -316,9 +316,9 @@ subroutine Compute_DestructionTerm(self, chi, fv1, vort, rho, theta, dwall, dest stilda = Compute_modifiedvorticity(self, vort, sbar) g = Compute_g(self, theta, dwall, stilda) fw = Compute_fw(self, g) - destruciton_Y = dimensionless % mu * self % cw1 * fw * (rho*POW2(theta))/(POW2(dwall)) + destruction_Y = dimensionless % mu * self % cw1 * fw * (rho*POW2(theta))/(POW2(dwall)) else - destruciton_Y = - dimensionless % mu * self % cw1 * (rho*POW2(theta))/(POW2(dwall)) + destruction_Y = - dimensionless % mu * self % cw1 * (rho*POW2(theta))/(POW2(dwall)) end if end subroutine Compute_DestructionTerm diff --git a/Solver/src/libs/sources/TripForceClass.f90 b/Solver/src/libs/sources/TripForceClass.f90 index dfc9e1258..3c2650d8f 100644 --- a/Solver/src/libs/sources/TripForceClass.f90 +++ b/Solver/src/libs/sources/TripForceClass.f90 @@ -406,38 +406,38 @@ Subroutine randSignal(self, signal) integer :: nh ! half of cuttoff number complex(kind=CP) :: fourierArg real(kind=RP), dimension(self%Ncutz/2+1) :: ranNum - real(kind=RP), dimension(0:self%N+1) :: fourierCoeficients, preSignal + real(kind=RP), dimension(0:self%N+1) :: fourierCoefficients, preSignal if ( MPI_Process % isRoot ) then nh = self%Ncutz/2 - ! the signal coefficients are initilialized at cero, it'll be changed for frequencies <= Ncutz - fourierCoeficients = 0_RP + ! the signal coefficients are initialized at zero, it'll be changed for frequencies <= Ncutz + fourierCoefficients = 0_RP ! the mean value, n=0 is random and ampliated by sqrt 2 for the real part and 0 for the img ! the coef array is packed in CCS format call random_number(ranNum) fourierArg = exp(ImgI*2.0_RP*PI*ranNum(1)) - fourierCoeficients(0) = real(fourierArg)*sqrt(2.0_RP) - fourierCoeficients(1) = 0 + fourierCoefficients(0) = real(fourierArg)*sqrt(2.0_RP) + fourierCoefficients(1) = 0 - ! for the other values of n less than the cutt off, the random amplitude is ampliated by sqrt 2 for the real part and 0 for the + ! for the other values of n less than the cut off, the random amplitude is ampliated by sqrt 2 for the real part and 0 for the ! img for the symmetric case ! for the non symmetric case, the amplitude is set to 1.0 and the phase is random (both real and part are saved) if (self%isSimetric) then do i = 1, nh fourierArg = exp(ImgI*2.0_RP*PI*ranNum(i+1)) - fourierCoeficients(2*i) = real(fourierArg)*sqrt(2.0_RP) - fourierCoeficients(2*i+1) = 0 + fourierCoefficients(2*i) = real(fourierArg)*sqrt(2.0_RP) + fourierCoefficients(2*i+1) = 0 end do else do i = 1, nh fourierArg = exp(ImgI*2.0_RP*PI*ranNum(i+1)) - fourierCoeficients(2*i) = real(fourierArg) - fourierCoeficients(2*i+1) = aimag(fourierArg) + fourierCoefficients(2*i) = real(fourierArg) + fourierCoefficients(2*i+1) = aimag(fourierArg) end do end if - call backfft(preSignal, self % N, fourierCoeficients) + call backfft(preSignal, self % N, fourierCoefficients) ! scale and give only the part of the array of interest end if if ( (MPI_Process % doMPIAction) ) then diff --git a/Solver/src/libs/timeintegrator/AnalyticalJacobian.f90 b/Solver/src/libs/timeintegrator/AnalyticalJacobian.f90 index 4a49e12c4..9d908328f 100644 --- a/Solver/src/libs/timeintegrator/AnalyticalJacobian.f90 +++ b/Solver/src/libs/timeintegrator/AnalyticalJacobian.f90 @@ -1762,7 +1762,7 @@ subroutine Local_GetOffDiagonalBlock(f,e_plus,e_minus,side,Matrix) * spAnorm_minus % v(elInd_minus( normAx_minus ),normAxSide_minus) & * dot_product( Gvec_tan2, nHat(:,faceInd_minus(1),faceInd_minus(2)) ) ! -! Faces contribution (surface integrals from the outer equation) - PENALTY TERM IS BEING CONSIDERED IN THE INVISCID PART - TODO: Reorganize storage to put it explicitely in another place (needed for purely viscous equations) +! Faces contribution (surface integrals from the outer equation) - PENALTY TERM IS BEING CONSIDERED IN THE INVISCID PART - TODO: Reorganize storage to put it explicitly in another place (needed for purely viscous equations) ! The tangent directions here are taken in the reference frame of e⁻ ! ********************************************************************* ! From b94a98e9ebc972deb38c74f89e3fb8cd29986bfd Mon Sep 17 00:00:00 2001 From: luz paz Date: Thu, 4 Aug 2022 20:09:59 -0400 Subject: [PATCH 2/2] Follow-up typos --- Solver/src/libs/physics/common/WallFunctionDefinitions.f90 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Solver/src/libs/physics/common/WallFunctionDefinitions.f90 b/Solver/src/libs/physics/common/WallFunctionDefinitions.f90 index 97ea1d9d7..1be313bd2 100644 --- a/Solver/src/libs/physics/common/WallFunctionDefinitions.f90 +++ b/Solver/src/libs/physics/common/WallFunctionDefinitions.f90 @@ -110,7 +110,7 @@ Subroutine Initialize_Wall_Function(controlVariables, correct) useAverageV = controlVariables%logicalValueForKey("wall function use average") - !todo: see if there are negative values and return if thats the case + !todo: see if there are negative values and return if that's the case ! write(STD_OUT,'(A)') "Wall function will not be activated" ! if it arrives here everything has gone well