The tiers are "Search Front End" which servers user queries and store the index and "Search Back End" which crawl and host the administration components.  The machinery is in place to add additional tiers if desired, just add in a new variable with server names and replicate a foreach() block in the "#Build and Set the Topology" section and adjust the services that should run on each tier.

The script will prompt for credentials that should be used for the Default Content Access Account.  Additionally, the managed account that the Search Service Application pool will run under must be a previously-configured managed account.

#Add SharePoint PowerShell snap-in
Add-PSSnapin microsoft.sharepoint.powershell

##### Set Local Variables
#Search Application Pool Name
$SearchAppPoolName = "SearchServicePool"
#Search Application Pool Account, must be a previously registered managed account
$SearchAppPoolAccount = “CONTOSO\account”
#Crawl Account Name
$CrawlAccount = Get-Credential -Message "Default Content Access Account Credentials"
#Search Service Application Name
$SearchAppName = "Search Service Application"
#Search Service Application Proxy Name
$SearchProxy = "$SearchAppName Proxy"
#Database Server that hosts the application
$DBServer = "SQL\instance"
#Root Database Name for Search Service Application
$DBName = "SP_Search"
#Drive Path where SharePoint should store the Search Index, must already exist.
$Indexlocation = “I:\Index”
#Search Front End Server List, separate each server with a comma.
$SearchFrontEnds = "Server1", "Server2”
#Search Application Servers List
$SearchAppSrvs = "Server1", "Server2”
#Get Application Pool for Search Administration Service, must already exist.
$AdminAppPool = Get-SPServiceApplicationPool -Identity "SearchServicePool"
#####

#Create Search Application Pool
"Provisioning Search Application Pool...” | Write-Host
$AppPool = New-SPServiceApplicationPool -Name $SearchAppPoolName -Account $SearchAppPoolAccount

#Start the search service instances on each of the search servers
"Starting Search Service Instances...” | Write-Host
foreach($ServerName in $SearchFrontEnds){
      Start-SPEnterpriseSearchServiceInstance -Identity $ServerName
      Start-SPEnterpriseSearchQueryAndSiteSettingsServiceInstance -Identity     $ServerName
      }
foreach($ServerName in $SearchAppSrvs){
      Start-SPEnterpriseSearchServiceInstance -Identity $ServerName
      Start-SPEnterpriseSearchQueryAndSiteSettingsServiceInstance -Identity     $ServerName
      }

#Wait for the Services to provision 
while(Get-SPEnterpriseSearchServiceInstance | ?{$_.status -eq "Provisioning"}){
      start-sleep 2
      }
#Confirm that everything provisioned correctly by cycling through the search servers and ensuring that the Search Service Instance is “Online”
foreach($ServerName in $SearchFrontEnds){
      if(!((Get-SPEnterpriseSearchServiceInstance -Identity $ServerName).status -eq "Online")){
            throw(“The Search Instance on $ServerName failed to provision.  Run Get-SPEnterpriseSearchServiceInstance to view the status of all Search Service Instances”)
            }
      }
foreach($ServerName in $SearchAppSrvs){
      if(!((Get-SPEnterpriseSearchServiceInstance -Identity $ServerName).status -eq "Online")){
            throw(“The Search Instance on $ServerName failed to provision.  Run Get-SPEnterpriseSearchServiceInstance to view the status of all Search Service Instances”)
            }
      }
"Search Instances Provisioned`n” | Write-Host

#Create Search Service Application and Application Proxy in SharePoint
"Provisioning Search Service Application and Proxy..." | Write-Host
New-SPEnterpriseSearchServiceApplication -Name $SearchAppName -ApplicationPool $SearchAppPoolName -DatabaseName $DBName -AdminApplicationPool $AdminAppPool
Start-Sleep 10
#Create Search Service Application and Proxy
New-SPEnterpriseSearchServiceApplicationProxy -Partitioned -Name $SearchProxy -SearchApplication $SearchAppName
Start-Sleep 10
Set-SPEnterpriseSearchServiceApplication -Identity $SearchAppName -DefaultContentAccessAccountName $CrawlAccount.Username -DefaultContentAccessAccountPassword $CrawlAccount.Password
$SearchServiceApp = Get-SPEnterpriseSearchServiceApplication -Identity $SearchAppName

##### Build and Set the Topology
#Create the Topology Object
"Building Search Topology...” | Write-Host
$newTopology = New-SPEnterpriseSearchTopology -SearchApplication $SearchServiceApp

#Define Search Front End Topology
foreach($ServerName in $SearchFrontEnds){
     $ServerInstance = Get-SPEnterpriseSearchServiceInstance -Identity $ServerName
     New-SPEnterpriseSearchQueryProcessingComponent -SearchTopology $newTopology -SearchServiceInstance $ServerInstance
     New-SPEnterpriseSearchIndexComponent -SearchTopology $newTopology -SearchServiceInstance $ServerInstance -RootDirectory $IndexLocation -IndexPartition 0
     }

#Define Search Application Server Topology
foreach($ServerName in $SearchAppSrvs){
     $ServerInstance = Get-SPEnterpriseSearchServiceInstance -Identity $ServerName
     New-SPEnterpriseSearchAdminComponent -SearchTopology $newTopology -SearchServiceInstance $ServerInstance
     New-SPEnterpriseSearchCrawlComponent -SearchTopology $newTopology -SearchServiceInstance $ServerInstance
     New-SPEnterpriseSearchContentProcessingComponent -SearchTopology $newTopology -SearchServiceInstance $ServerInstance
     New-SPEnterpriseSearchAnalyticsProcessingComponent -SearchTopology $newTopology -SearchServiceInstance $ServerInstance
     }

#Set the Topology
"Setting Topology..." | Write-Host
Start-Sleep 2
Set-SPEnterpriseSearchTopology -Identity $newTopology
"All Done,`nCheck the Search Administration page in Central Administration to verify” | Write-Host

It can be difficult to test and is often left un-verified because short of having a server sit there and ping the rest of the farm for 10 minutes, there is no way to ensure that the environment is compliant.  To solve this, I have written a script that leaves one of the servers sitting around pinging the rest of the farm for 10 minutes and reports back on whether the environment complies.

The Script performs the following tests:

 - Check connectivity in the farm and make sure all servers are reachable. (this saves you from wasting 10 minutes waiting for the script to run only to find out the hosts weren't reachable)

 - Open an ODBC connection to the database server. (This is always handy)

 - Verify the environment meets the SharePoint hardware requirement that 99.9% of pings between servers in the farm take less than 1ms over a 10 minute period.  For convenience, how long this runs can be changed by setting the $RunTime variable to a lower value.

To run the script, either copy and paste the code into PowerShell_ISE and run it, or save it as a .ps1 file, right click it and select "Run with PowerShell".  The second method requires the powershell execution policy to be "unrestricted" (to set, run Set-ExecutionPolicy Unrestricted).

 #####Set Local Variables
 #Set Host Names, or IP Addresses
 $hostnames = "10.0.0.1", "SomeHost"
 #SQL Server Name\Instance
 $SQLname = "SQL\Instance"
 #Configure Run Time in Minutes (helpful for debugging)
 $RunTime = 10
 #Configure an allowance for late pings (in ms, one way)
 $allowance = 0
 #####
 
 ### test connectivity ###
 Write-Host "Test Connectivity:"
 
 Write-Host "Testing Ping"
 $ping = New-Object System.Net.NetworkInformation.ping
 
 foreach($a in $hostnames){
 $status = $ping.send($a).Status
 if($status -ne "Success"){
 throw "Ping Failed to $($a)"
 }
 }
 Write-Host " - Succeeded `n"
 
 
 
 ### test SQL connectivity ###
 Write-Host "Testing SQL Connection"
 $SQLConnection = New-Object System.Data.Odbc.OdbcConnection
 $SQLConnection.connectionstring = "Driver={SQL Server};Server=$SQLname"
 $SQLConnection.open()
 if($SQLConnection.state -ne "Open"){
 throw "SQL Connection Failed"
 }
 Write-Host " - Succeeded `n"
 
 
 
 ### Intra-server latency consistency test ###
 Write-Host "Start network consistency test"
 
 
 $ScriptBlock = {
 # accept the loop variable across the job-context barrier
 param($InHost, $RunTime) 
 
 $start = [DateTime]::Now
 $ping = New-Object System.Net.NetworkInformation.ping
 
 $PingResults = @()
 while([datetime]::now -le $start.AddMinutes($RunTime)){ 
 $outping = $ping.send($InHost)
 if($outping.Status -ne "Success"){
 $PingResults = $PingResults + 100
 } else{
 $PingResults = $PingResults + $outping.RoundtripTime
 }
 Start-Sleep .1
 } 
 return $PingResults
 }
 
 
 #run ping jobs in parallel
 foreach($i in $hostnames){
 Start-Job $ScriptBlock -ArgumentList $i, $RunTime -Name "$i.latency_test"
 }
 
 Write-Host "
 processing...`n"
 
 #wait and clean up
 While (Get-Job -State "Running") { Start-Sleep 5 }
 
 $output = @{}
 foreach($i in $hostnames){
 $output[$i] = Receive-Job -Name "$i.latency_test"
 }
 Remove-Job *
 
 #test results
 $LatencyTestFailed = 0
 foreach($i in $hostnames){
 $BadPings = $output[$i] | ?{$_/2 -ge 1 + $allowance}
 $PercentBadPings = $BadPings.length / $output[$i].Length * 100
 if($PercentBadPings -ge .1){
 "$i DOES NOT meet the latency requirements with $PercentBadPings % of pings >$(1+$allowance)ms" | Write-Host
 $LatencyTestFailed = 1
 } else{
 "$i meets the latency requirements with $PercentBadPings % of pings >$(1+$allowance)ms" | Write-Host
 }
 }
 if($LatencyTestFailed -eq 1){
 throw "Farm Latency Test Failed"
 } 

https://technet.microsoft.com/en-us/library/ff686793.aspx

This task can be somewhat difficult because assembling the prerequisites can be time consuming and running prerequisiteinstaller.exe with an arguments file presents some challenges (See the known issues section at the end of the above article).

To solve these, I have two scripts: one that runs prerequisiteinstaller.exe with inline arguments, eliminating the need to delete the startup task on the server and one that downloads all of the required files to a share.

To install the prereqs from a share, run the following PowerShell script on the server you want to install SharePoint on with #path changed to the location of the network share where you have downloaded the SharePoint prerequisites:

 ##### Set Local Variables 
 #Root Prerequisites Directory 
 $PrereqRoot = "#Path” 
 #SharePoint Install Media Directory 
 $SPRoot = "#Path” 
 ##### 
 
 
 cd $SPRoot 
 .\PrerequisiteInstaller.exe /SQLNCli:"$PrereqRoot\sqlncli.msi" /PowerShell:"$PrereqRoot\Windows6.1-KB2506143-x64.msu" /NETFX:"$PrereqRoot\dotnetfx45_full_x86_x64.exe" /IDFX:"$PrereqRoot\Windows6.1-KB974405-x64.msu" /Sync:"$PrereqRoot\Synchronization.msi" /AppFabric:"$PrereqRoot\WindowsServerAppFabricSetup_x64.exe" /IDFX11:"$PrereqRoot\MicrosoftIdentityExtensions-64.msi" /MSIPCClient:"$PrereqRoot\setup_msipc_x64.msi" /WCFDataServices:"$PrereqRoot\WcfDataServices.exe" /KB2671763:"$PrereqRoot\AppFabric1.1-RTM-KB2671763-x64-ENU.exe" 
 

To download all required files to a network share, run the following on an internet connected computer with access to the fileshare you want to use.  Replace #path with the network location you want to store the prerequisites on:

 #Import Required Modules 
 Import-Module BitsTransfer 
 
 ##### Set Local Variables 
 #Define the path of the target network share 
 $TargetRoot = "#Path” 
 ##### 
 
 #Create Target if needed 
 if(!(Test-Path $TargetRoot)){ 
 New-Item $TargetRoot -ItemType Directory -Force 
 } 
 　 
 #Set the download targets. Note these URLs may be subject to change, check https://technet.microsoft.com/en-us/library/cc262485(v=office.15).aspx for a list of prerequisites. 
 $PrereqURLs = ( 
 #Microsoft .NET Framework version 4.5 
 "https://download.microsoft.com/download/b/a/4/ba4a7e71-2906-4b2d-a0e1-80cf16844f5f/dotnetfx45_full_x86_x64.exe", 
 
 #SQL Server 2008 R2 SP1 Native Client 
 "https://download.microsoft.com/download/9/1/3/9138773A-505D-43E2-AC08-9A77E1E0490B/1033/x64/sqlncli.msi", 
 
 #Microsoft WCF Data Services 5.0 
 "https://download.microsoft.com/download/8/F/9/8F93DBBD-896B-4760-AC81-646F61363A6D/WcfDataServices.exe", 
 
 # Microsoft Information Protection and Control Client (MSIPC) 
 "https://download.microsoft.com/download/9/1/D/91DA8796-BE1D-46AF-8489-663AB7811517/setup_msipc_x64.msi", 
 
 #Microsoft Sync Framework Runtime v1.0 SP1 (x64) 
 "https://download.microsoft.com/download/E/0/0/E0060D8F-2354-4871-9596-DC78538799CC/Synchronization.msi", 
 
 #Windows Management Framework 3.0 which includes Windows PowerShell 3.0 
 "https://download.microsoft.com/download/5/2/B/52B59966-3009-4F39-A99E-3732717BBE2A/Windows6.1-KB2506143-x64.msu", 
 
 #Windows Identity Extensions 
 "https://download.microsoft.com/download/0/1/D/01D06854-CA0C-46F1-ADBA-EBF86010DCC6/r2/MicrosoftIdentityExtensions-64.msi", 
 
 #Windows Identity Foundation (KB974405) 
 "https://download.microsoft.com/download/D/7/2/D72FD747-69B6-40B7-875B-C2B40A6B2BDD/Windows6.1-KB974405-x64.msu", 
 
 #Windows Server AppFabric 
 "https://download.microsoft.com/download/A/6/7/A678AB47-496B-4907-B3D4-0A2D280A13C0/WindowsServerAppFabricSetup_x64.exe", 
 
 #CU 1 for AppFabric 1.1 (KB2671763) 
 "https://download.microsoft.com/download/7/B/5/7B51D8D1-20FD-4BF0-87C7-4714F5A1C313/AppFabric1.1-RTM-KB2671763-x64-ENU.exe" 
 ) 
 
 #Download Files to Target 
 "Downloading Files" | Write-Host 
 
 foreach($URL in $PrereqURLs){ 
 #The folder name should be the last "/" of the URL 
 $Name = $URL.Split('/')[-1] 
 
 #Current Download 
 "$Name..." | Write-Host 
 
 #Download Files, skip if unneccesary. 
 if(!(Test-Path $TargetRoot\$Name)){ 
 Start-BitsTransfer -Source $URL -Destination $TargetRoot\$Name -Priority High 
 "Downloading...`n" | Write-Host 
 } else{ 
 "Already Downloaded`n" | Write-Host 
 } 
 } 
 
 #Acknowledgements to Muawiyah Shannak whose script this is based off of. The original can be found here https://gallery.technet.microsoft.com/Script-to-SharePoint-2013-702e07df